類和物件
創建方法
第一種式直接宣告：
class Student {
private:
string name;
public:
Student(string name) {
this->name = name;
}
}
//宣告：
Student lu;//不帶初始化
//帶初始化；
Student lu(huang);
Student lu = Student(huang);
//訪問方式
lu.name;
這樣的宣告方式，是將物件在堆疊上創建，堆疊記憶體自動管理，在執行函式時，函式內區域變數的存盤單元都可以在堆疊上創建，函式執行結束后在將這些區域變數的記憶體空間回收，在堆疊上分配記憶體空間效率很高，但是分配的記憶體容量有限，
第二種使用物件指標宣告
Student *plu = new Student;//不帶初始化；
Student *plu = new Student(huang);//帶初始化；
//訪問方式
plu->name;
這樣宣告，是將物件在堆中創建，堆記憶體代碼人員管理，new和delete配對使用，使用 new 在堆上創建出來的物件是匿名的，沒法直接使用，必須要用一個指標指向它，再借助指標來訪問它的成員變數或成員函式，
函式宣告
成員函式必須先在類體中作原型宣告，然后在類外定義，也就是說類體的位置應在函式定義之前，因為類體內定義的函式默認是行內函式，一般用行內函式的時候才會在類內部實作；例子：
class Student {
private:
string name;
int age;
public:
//函式宣告
Student(string name, int age);
}
//函式定義
Student::Student(string name, int age) {
this->name = name;
this->age = age;
}
類成員的訪問權限以及封裝
在類的內部（定義類的代碼內部），無論成員被宣告為 public、protected 還是 private，都是可以互相訪問的，沒有訪問權限的限制，
在類的外部（定義類的代碼之外），只能通過物件訪問成員，并且通過物件只能訪問 public 屬性的成員，不能訪問 private、protected 屬性的成員，
成員變數大都以m_開頭，這是約定成俗的寫法，易區分，
建議在開發中不需要暴暴露出來的屬性和方法都寫成private；
給成員變數賦值的函式通常稱為 set XXX函式，讀取成員變數的值的函式通常稱為 get XXX函式，XXX表示變數名；類中的不寫private這些關鍵詞默認是private；
class Student {
private:
string m_name;
public:
void setname(string name);
void getname;
}
void Student::setname(string name) {
m_name = name;//這里可以直接用m_name;
}
.....
物件記憶體模型和函式編譯原理及實作
編譯器會將成員變數和成員函式分開存盤：分別為每個物件的成員變數分配記憶體，但是所有物件都共享同一段函式代碼，節省空間，sizeof一個物件大小就是全部成員變數的總和大小；
C++和C語言的編譯方式不同，C語言中的函式在編譯時名字不變，或者只是簡單的加一個下劃線_（不同的編譯器有不同的實作），c++是通過一種特殊的演算法來實作的，對函式重命名（這個程序叫字編碼（Name Mangling））；下圖是一個編譯器重命名的方式，？方法@類名.....
從上圖可以看出，成員函式最終被編譯成與物件無關的全域函式，如果函式體中沒有成員變數，不用對函式做任何處理，直接呼叫即可，
如果由成員變數（它的作用域不是全域的），C++規定，編譯成員函式時要額外添加一個引數，把當前物件的指標傳遞進去，通過指標來訪問成員變數（實際上傳遞的就是this指標）
void Demo::display(){
cout<<a<<endl;
}
會編譯為類似：
void new_function_name(Demo * const p){//const表示指標不能被修改；
//通過指標p來訪問a、b
cout<<p->a<<endl;
}
這樣通過傳遞物件指標就完成了成員函式和成員變數的關聯，這與我們從表明上看到的剛好相反，通過物件呼叫成員函式時，不是通過物件找函式，而是通過函式找物件，
建構式
建構式的呼叫是強制性的，一旦在類中定義了建構式，那么創建物件時就一定要呼叫，不呼叫是錯誤的，如果有多個多載的建構式，那么創建物件時提供的實參必須和其中的一個建構式匹配；反過來說，創建物件時只有一個建構式會被呼叫；
一個類必須有建構式，要么用戶自己定義，要么編譯器自動生成，一旦用戶自己定義了建構式，不管有幾個，也不管形參如何，編譯器都不再自動生成，
建構式定義由兩種寫法：正常函式寫法和使用建構式初始化串列
//第一種
Student::Student(char *name, int age){
m_name = name;
m_age = age;
}
//第二種
Student::Student(char *name, int age): m_name(name), m_age(age){}
注意??第二種：成員變數的初始化順序與初始化串列中列出的變數的順序無關，它只與成員變數在類中宣告的順序有關；如：
class Demo{
private:
int m_a;
int m_b;
public:
Demo(int b);
void show();
};
Demo::Demo(int b): m_b(b), m_a(m_b){
m_a = m_b;
m_b = b;
}
//錯誤，給 m_a 賦值時，m_b 還未被初始化，它的值是不確定的，所以輸出的 m_a 的值是一個奇怪的數字；給 m_a 賦值完成后才給 m_b 賦值，此時 m_b 的值才是 值b，
//obj 在堆疊上分配記憶體，成員變數的初始值是不確定的，
使用建構式初始化串列并沒有效率上的優勢,但是書寫方便，而且，初始化 const 成員變數的唯一方法就是使用初始化串列，原因：為什么要用初始化串列
解構式
解構式（Destructor）也是一種特殊的成員函式，沒有回傳值，不需要程式員顯式呼叫（程式員也沒法顯式呼叫），而是在銷毀物件時自動執行，
class VLA{
public:
VLA(int len); //建構式
~VLA(); //解構式
private:
const int m_len; //陣列長度
int *m_arr; //陣列指標
int *m_p; //指向陣列第i個元素的指標
};
VLA::VLA(int len): m_len(len){ //使用初始化串列來給 m_len 賦值
if(len > 0){ m_arr = new int[len]; /*分配記憶體*/ }
else{ m_arr = NULL; }
}
VLA::~VLA(){
delete[] m_arr; //釋放記憶體
}
通過直接用類宣告的物件在堆疊中，出了作用域（比如說函式return了），就會呼叫解構式；在全域建的物件在.data區，程式結束后才釋放； 注意?????♂?：兩中方法呼叫解構式的順序都是先生成的后析構，后生成的先析構；
new 創建的物件位于堆區，通過 delete 洗掉時才會呼叫解構式，例如在main函式中new物件然后delete物件；如果宣告了變數在堆中，不通過解構式釋放記憶體，即使外面delete了，也只是洗掉了指標，里面的空間還是被占用著，沒有被釋放掉，如上面的int[len]；
此處補充指標知識：
int a = 10;
int* p = &a;//p是指標，這個*表示是int的指標型別；
此時 *p = 10//這里的*說明是這個指標指向的物件，與上面*大大不同；而p只是以一個地址
成員物件和封閉類
一個類的成員變數如果是另一個類的物件，就稱之為“成員物件”，包含成員物件的類叫封閉類，
創建封閉類的物件時，它包含的成員物件也需要被創建，這就會引發成員物件建構式的呼叫，對于沒有默認建構式的成員物件，必須要使用封閉類建構式的初始化串列！！！
類名::建構式名(引數表): 成員變數1(引數表), 成員變數2(引數表), ...
{
//TODO:
}
一定要用初始化串列的四種情況
初始化時：封閉類物件生成時，先執行所有成員物件的建構式，然后才執行封閉類自己的建構式；
消亡時：先執行封閉類的解構式，然后再執行成員物件的解構式，剛剛好和創建相反，
this指標、static關鍵字
C++ 中的一個關鍵字，也是一個 const 指標， 所以要用->來訪問成員變數或成員函式，它指向當前物件，通過它可以訪問當前物件的所有成員，
this的本質：this 實際上是成員函式的一個形參，在呼叫成員函式時將物件的地址作為實參傳遞給 this，不過 this 這個形參是隱式的，它并不出現在代碼中，而是在編譯階段由編譯器默默地將它添加到引數串列中，
上述中函式編譯原理：成員函式最終被編譯成與物件無關的普通函式，除了成員變數，會丟失所有資訊，所以編譯時要在成員函式中添加一個額外的引數，把當前物件的首地址傳入，以此來關聯成員函式和成員變數，這個額外的引數，實際上就是 this，它是成員函式和成員變數關聯的橋梁，
static修飾成員變數：
-
一個類中可以有一個或多個靜態成員變數，所有的物件都共享這些靜態成員變數，都可以參考它，
-
static 成員變數和普通 static 變數一樣，都在記憶體磁區中的全域資料區分配記憶體，到程式結束時才釋放，這就意味著，static 成員變數不隨物件的創建而分配記憶體，也不隨物件的銷毀而釋放記憶體，而普通成員變數在物件創建時分配記憶體，在物件銷毀時釋放記憶體，
-
靜態成員變數必須初始化，而且只能在類體外進行，例如：int Student::m_total = 10;初始化時可以賦初值，也可以不賦值，如果不賦值，那么會被默認初始化為 0，全域資料區的變數都有默認的初始值 0，而動態資料區（堆區、堆疊區）變數的默認值是不確定的，一般認為是垃圾值，
-
靜態成員變數既可以通過物件名訪問，也可以通過類名訪問，但要遵循 private、protected 和 public 關鍵字的訪問權限限制，當通過物件名訪問時，對于不同的物件，訪問的是同一份記憶體，
static修飾成員函式：
靜態成員函式與普通成員函式的根本區別在于：普通成員函式有 this 指標，可以訪問類中的任意成員；而靜態成員函式沒有 this 指標，只能訪問靜態成員（包括靜態成員變數和靜態成員函式）
原因：編譯器在編譯一個普通成員函式時，會隱式地增加一個形參 this，并把當前物件的地址賦值給 this，所以普通成員函式只能在創建物件后通過物件來呼叫，因為它需要當前物件的地址，而靜態成員函式可以通過類來直接呼叫，編譯器不會為它增加形參 this，它不需要當前物件的地址，所以不管有沒有創建物件，都可以呼叫靜態成員函式，所以靜態成員函式也無法訪問普通成員變數，只能訪問靜態成員（在全域），
const 成員變數/成員函式(常成員函式)/物件
const成員變數：加上 const 關鍵字，初始化 const 成員變數只有一種方法，就是通過建構式的初始化串列
const成員函式： const 成員函式可以使用類中的所有成員變數，但是不能修改它們的值，這種措施主要還是為了保護資料而設定的，一般類中的get函式都設定為常成員函式，只讀不給改；
-
函式開頭的 const 用來修飾函式的回傳值，表示回傳值是 const 型別，也就是不能被修改，例如
const char * getname()， -
函式頭部的結尾加上 const 表示常成員函式，這種函式只能讀取成員變數的值，而不能修改成員變數的值，例如
char * getname() constclass Student { public: Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score) {}//方法實作都不寫; char *getname() const; prviate: char *m_name; int m_age; float m_score; }; char* Student::getname() const { return m_name; }//方法實作都不寫;
const物件： const 也可以用來修飾物件，稱為常物件，一旦將物件定義為常物件之后，就只能呼叫類的 const 成員（包括 const 成員變數和 const 成員函式）了，因為非 const 成員可能會修改物件的資料（編譯器也會這樣假設），C++禁止這樣做，
友元函式和友元類
借助友元（friend），可以使得其他類中的成員函式以及全域范圍內的函式訪問當前類的 private 成員，在當前類以外定義的、不屬于當前類的函式也可以在類中宣告，但要在前面加 friend 關鍵字，這樣就構成了友元函式，友元函式可以是不屬于任何類的 非成員函式，也可以是其他類的成員函式，
- 將非成員函式宣告為友元函式
class Student{
public:
Student(char *name, int age, float score);
public:
friend void show(Student *pstu); //將show()宣告為友元函式
private:
char *m_name;
int m_age;
float m_score;
};
//非成員函式
void show(Student *pstu){//屬于全域函式，通過引數傳遞物件，可以訪問private成員變數
cout<<pstu->m_name<<"的年齡是 "<<pstu->m_age<<"，成績是 "<<pstu->m_score<<endl;
}
- 將其他類的成員函式宣告為友元函式，該成員函式提供給一個類用
class Address; //一定要提前宣告Address類
//宣告Student類
class Student{
public:
Student(char *name, int age, float score);
public:
void show(Address *addr);//要使用的類，前面有宣告address所以不會報錯！！！！！！！！！！！！！！！！！
private:
char *m_name;
int m_age;
float m_score;
};
//宣告Address類
class Address{
private:
char *m_province; //省份
char *m_city; //城市
char *m_district; //區（市區）
public:
Address(char *province, char *city, char *district);
//將Student類中的成員函式show()宣告為友元函式
friend void Student::show(Address *addr);//！！！！！！！！！！！！！！！！！！！
};
//實作Student類
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(Address *addr){
cout<<m_name<<"的年齡是 "<<m_age<<"，成績是 "<<m_score<<endl;
cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"區"<<endl;
}
友元類：
將類 B 宣告為類 A 的友元類，那么類 B 中的所有成員函式都是類 A 的友元函式，可以訪問類 A 的所有成員，包括 public、protected、private 屬性的
class Address; //提前宣告Address類
//宣告Student類
class Student{
public:
Student(char *name, int age, float score);
public:
void show(Address *addr);
private:
char *m_name;
int m_age;
float m_score;
};
//宣告Address類
class Address{
public:
Address(char *province, char *city, char *district);
public:
//將Student類宣告為Address類的友元類
friend class Student;
private:
char *m_province; //省份
char *m_city; //城市
char *m_district; //區（市區）
};
//實作Student類
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(Address *addr){
cout<<m_name<<"的年齡是 "<<m_age<<"，成績是 "<<m_score<<endl;
cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"區"<<endl;
}
//實作Address類
Address::Address(char *province, char *city, char *district){
m_province = province;
m_city = city;
m_district = district;
}
- 友元的關系是單向的而不是雙向的，如果宣告了類 B 是類 A 的友元類，不等于類 A 是類 B 的友元類，類 A 中的成員函式不能訪問類 B 中的 private 成員，
- 友元的關系不能傳遞，如果類 B 是類 A 的友元類，類 C 是類 B 的友元類，不等于類 C 是類 A 的友元類，
- 除非有必要，一般不建議把整個類宣告為友元類，而只將某些成員函式宣告為友元函式，這樣更安全一些，
ps： 其實類也是一種作用域 ， 普通的成員只能通過物件（可以是物件本身，也可以是物件指標或物件參考）來訪問，靜態成員既可以通過物件訪問，又可以通過類訪問，而 typedef 定義的型別只能通過類來訪問
struct和class的區別
C++中，struct 類似于 class，既可以包含成員變數，又可以包含成員函式，
C++中的 struct 和 class 基本是通用的，唯有幾個細節不同：
- 使用 class 時，類中的成員默認都是 private 屬性的；而使用 struct 時，結構體中的成員默認都是 public 屬性的，
- class 繼承默認是 private 繼承，而 struct 繼承默認是 public 繼承（到繼承會講），
- class 可以使用模板，而 struct 不能（到模板會講），
建議使用 class 來定義類，而使用 struct 來定義結構體，這樣做語意更加明確
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/472233.html
標籤：C++