目錄

一、對象數組

二、對象指針

三、this 指針

四、類類型作為參數類型的三種形式

4.1 對象本身作為參數

4.2 對象指針作為參數

4.3 對象引用作為參數

五、靜態成員

5.1?靜態數據成員

5.2?靜態成員函數

六、友元機制

6.1 友元函數

6.2 友元類

七、類的組合

八、數據成員的初始化和釋放順序

九、常對象與常成員

9.1 常對象

9.2 常成員

9.2.1 常成員函數

9.2.2 常成員數據

---

一、對象數組

在C++中，可以使用對象數組來存儲和操作一組相關的對象。下面是一個示例：

class Student {
private:std::string name;int age;std::string gender;public:// 構造函數Student(std::string n, int a, std::string g) {name = n;age = a;gender = g;}// Getter 和 Setter 方法std::string getName() {return name;}void setName(std::string n) {name = n;}int getAge() {return age;}void setAge(int a) {age = a;}std::string getGender() {return gender;}void setGender(std::string g) {gender = g;}
};int main() {// 聲明一個存儲 Student 對象的數組Student students[10];// 初始化數組中的每個對象students[0] = Student("張三", 18, "男");students[1] = Student("李四", 19, "女");// ...// 訪問對象數組中的元素std::cout << "第一個學生的姓名是：" << students[0].getName() << std::endl;std::cout << "第二個學生的年齡是：" << students[1].getAge() << std::endl;// 修改對象數組中的元素students[0].setName("王五");students[1].setAge(20);return 0;
}

在上面的示例中，Student 是一個自定義的類，有姓名、年齡和性別等屬性。然后在main函數中聲明了一個名為students的對象數組，用來存儲多個學生對象。可以通過索引訪問和操作每個學生對象。最后，通過對象數組可以方便地對一組學生對象進行管理和操作。

二、對象指針

對象指針是指指向對象的指針變量。在C++中，可以通過使用對象指針來操作對象的成員和調用成員函數。

通過對象指針可以訪問對象的成員，使用?->運算符可以在指針上調用成員函數和訪問成員變量。例如，studentPtr->getName()會調用Student對象的getName()函數。

下面是一個示例：

class Student {
private:std::string name;int age;std::string gender;public:// 構造函數Student(std::string n, int a, std::string g) {name = n;age = a;gender = g;}// Getter 和 Setter 方法std::string getName() {return name;}void setName(std::string n) {name = n;}int getAge() {return age;}void setAge(int a) {age = a;}std::string getGender() {return gender;}void setGender(std::string g) {gender = g;}
};int main() {// 聲明一個指向 Student 對象的指針Student* studentPtr;// 創建一個 Student 對象，并將指針指向該對象Student student("張三", 18, "男");studentPtr = &student;// 通過指針訪問對象的成員std::cout << "學生的姓名是：" << studentPtr->getName() << std::endl;std::cout << "學生的年齡是：" << studentPtr->getAge() << std::endl;// 通過指針調用對象的成員函數studentPtr->setName("王五");studentPtr->setAge(20);return 0;
}

在上面的示例中，Student是一個自定義的類，有姓名、年齡和性別等屬性。然后在main函數中聲明了一個名為studentPtr的指針變量，用來指向Student對象。通過使用?&操作符，我們將指針studentPtr指向了一個實際的Student對象?student。

注意：

• 當使用對象指針時，必須確保指針指向的對象是有效的（未被銷毀）。否則，在使用指針訪問成員時可能會導致程序崩潰或未定義行為。

三、this 指針

this指針是一個指向當前對象的指針，它可以在類的成員函數中使用。在C++中，每個非靜態成員函數都有一個隱含的this指針，它指向調用該函數的對象。通過this指針，可以在成員函數中訪問和操作對象的成員變量和成員函數。

下面是一個示例：

class MyClass {
private:int value;public:// 構造函數MyClass(int v) {value = v;}// 成員函數void printValue() {std::cout << "對象的值是：" << value << std::endl;}void setValue(int v) {this->value = v;}void printAddress() {std::cout << "對象的地址是：" << this << std::endl;}
};int main() {MyClass obj(10);obj.printValue();obj.setValue(20);obj.printValue();obj.printAddress();return 0;
}

在上面的示例中，MyClass是一個包含一個私有成員變量value和一些成員函數的類。在printValue函數中，我們使用this指針來訪問對象的成員變量value并打印出來。在setValue函數中，我們使用this指針來設置對象的成員變量value的值。

this指針還可以用于獲取對象的地址，如printAddress函數所示。通過打印this指針，我們可以看到它指向的是創建的對象的地址。

注意：

• this指針是一個常量指針，不能被修改和賦值。所以不能將this指針作為參數傳遞給其他函數或賦值給其他指針變量。它只能被用于訪問當前對象的成員。

四、類類型作為參數類型的三種形式

4.1 對象本身作為參數

在C++中，可以將一個類類型的對象本身作為參數傳遞給函數。這意味著函數可以直接操作和修改對象的成員變量和成員函數。

示例如下：

#include <iostream>class MyClass {
public:int x;MyClass(int a) {x = a;}void func() {std::cout << "x的值為: " << x << std::endl;}
};void modifyObject(MyClass obj) {obj.x = 10;
}int main() {MyClass obj(5);obj.func(); // 輸出: x的值為: 5modifyObject(obj);obj.func(); // 輸出: x的值為: 5（對象本身不會被修改）return 0;
}

在上面的示例中，我們定義了一個名為MyClass的類，它包含一個整型成員變量x?和一個成員函數func()。然后，我們定義了一個函數modifyObject()，它接受一個MyClass對象作為參數。在modifyObject()函數中，我們試圖修改傳遞進來的對象的?x成員變量的值，但實際上，這個修改只在modifyObject()函數內部生效，并不會影響到調用函數時傳遞的原始對象。所以，在主函數main()中，我們調用modifyObject(obj)后，再次輸出obj.x的值時，它的值仍然是調用前的原始值。

注意：

• 當將一個對象作為參數傳遞給函數時，C++會調用對象的拷貝構造函數來創建一個新的對象。這意味著函數內部對該對象的修改不會影響到原始對象。如果希望在函數內部修改原始對象的值，可以將對象作為引用或指針來傳遞。

4.2 對象指針作為參數

在C++中，我們可以將對象指針作為函數的參數來傳遞對象。使用對象指針作為參數可以使函數對對象進行原地修改，而不必復制對象或返回新對象。

下面是一個簡單的示例，展示了如何將對象指針作為參數傳遞：

#include <iostream>class MyClass {
public:int num;void printNum() {std::cout << "The number is: " << num << std::endl;}
};// 接受對象指針作為參數的函數
void updateNum(MyClass* obj, int newNum) {obj->num = newNum;
}int main() {MyClass obj;obj.num = 10;obj.printNum();  // 輸出: The number is: 10updateNum(&obj, 20);obj.printNum();  // 輸出: The number is: 20return 0;
}

在上面的示例中，我們定義了一個MyClass類，它包含一個整數成員變量num?和一個打印成員變量的函數printNum()。我們還定義了一個名為updateNum()的函數，它接受一個MyClass對象指針和一個新的整數值，并將對象的num變量更新為新值。

在main()函數中，我們創建一個MyClass對象obj，并將其變量設置為10。我們調用updateNum()函數，將obj的指針和新值20作為參數傳遞。這樣，updateNum()函數就可以直接操作obj的num變量，并將其值更新為20。最后，我們再次調用printNum()函數來驗證num變量是否已經更新為20。

注意：

• 在使用對象指針時要確保對象是有效的，并在不再需要時及時釋放內存。

4.3 對象引用作為參數

在C++中，我們可以將對象引用作為函數的參數來傳遞對象。使用對象引用作為參數可以使函數對對象進行原地修改，而不必復制對象或返回新對象。與對象指針相比，不需要使用額外的操作符來訪問成員變量。同時，對象引用也自動處理了對象是否為有效的情況，因此不需要在使用之前進行額外的檢查。

下面是一個簡單的示例，展示了如何將對象引用作為參數傳遞：

#include <iostream>class MyClass {
public:int num;void printNum() {std::cout << "The number is: " << num << std::endl;}
};// 接受對象引用作為參數的函數
void updateNum(MyClass& obj, int newNum) {obj.num = newNum;
}int main() {MyClass obj;obj.num = 10;obj.printNum();  // 輸出: The number is: 10updateNum(obj, 20);obj.printNum();  // 輸出: The number is: 20return 0;
}

在上面的示例中，我們定義了一個MyClass類，它包含一個整數成員變量num和一個打印成員變量的函數printNum()。我們還定義了一個名為updateNum()的函數，它接受一個MyClass對象引用和一個新的整數值，并將對象的num變量更新為新值。

在main()函數中，我們創建一個MyClass對象obj，并將其num變量設置為10。然后，我們調用updateNum()函數，將obj和新值20作為參數傳遞。這樣，updateNum()函數就可以直接操作obj的num變量，并將其值更新為20。最后，我們再次調用printNum()函數來驗證num變量是否已經更新為20。

注意：

• 一旦對象引用作為參數傳遞給函數，函數內部對對象的修改將會影響到原始對象。因此，在使用對象引用作為函數參數時，要格外小心，確保不會意外修改對象的狀態。

五、靜態成員

靜態成員是類的成員，而不是對象的成員。它們與類相關聯，而不是與特定的對象相關聯。靜態成員在類的所有對象之間共享，并且可以通過類名來訪問，而不需要創建類的實例。

靜態成員可以是靜態數據成員或靜態成員函數。靜態數據成員在類中只有一個實例，并且可以在所有對象之間共享。靜態成員函數不依賴于任何特定對象的實例，可以直接通過類名來調用。

5.1?靜態數據成員

在C++中，靜態數據成員是類的特殊成員，它被該類的所有對象所共享，而不是每個對象獨立擁有。靜態數據成員的值在類的所有對象中是相同的。

靜態數據成員具有以下特點：

1. 靜態數據成員屬于整個類，而不是類的某個具體對象。它在內存中只有一份拷貝，而不是每個對象都有一份。
2. 靜態數據成員可以在類的內部聲明，在類的外部進行定義和初始化。在定義時，需要在成員名稱前加上static關鍵字，同時需要在類的外部進行變量的定義和初始化。
3. 靜態數據成員的作用域限定在所屬的類內部，可以通過類名和作用域解析操作符::來直接訪問。
4. 靜態數據成員可以在類的對象之間共享數據，可以用于在對象之間傳遞共享的數據。

以下是一個示例：

class MyClass {
public:static int myStaticVar;  // 靜態數據成員的聲明static int getStaticVar() {  // 靜態成員函數可以直接訪問靜態數據成員return myStaticVar;}
};int MyClass::myStaticVar = 0;  // 靜態數據成員的定義和初始化int main() {MyClass obj1;MyClass obj2;obj1.myStaticVar = 5;cout << obj1.myStaticVar << endl;  // 輸出 5cout << obj2.myStaticVar << endl;  // 輸出 5，靜態數據成員在所有對象中共享cout << MyClass::myStaticVar << endl;  // 通過類名訪問靜態數據成員return 0;
}

在以上示例中，myStaticVar是一個靜態成員變量，通過類名來訪問。通過對象obj1和obj2來訪問myStaticVar，它們都共享相同的值。靜態成員函數getStaticVar()可以直接訪問靜態數據成員。

5.2?靜態成員函數

在C++中，靜態成員函數是屬于整個類的，而不是類的某個對象，它不依賴于特定的對象實例。靜態成員函數可以直接通過類名來調用，而不需要創建對象。

靜態成員函數具有以下特點：

1. 靜態成員函數沒有this指針，因此不能直接訪問非靜態成員變量和非靜態成員函數。它只能訪問靜態成員變量和靜態成員函數。
2. 靜態成員函數可以在類的內部聲明，在類的外部進行定義。
3. 靜態成員函數的調用方式是通過類名和作用域解析操作符::來調用。

以下是一個示例：

class MyClass {
public:static int myStaticVar;  // 靜態數據成員的聲明static int getStaticVar() {  // 靜態成員函數的定義return myStaticVar;}static void setStaticVar(int value) {myStaticVar = value;}
};int MyClass::myStaticVar = 0;  // 靜態數據成員的定義和初始化int main() {MyClass::setStaticVar(5);  // 通過類名調用靜態成員函數cout << MyClass::getStaticVar() << endl;  // 通過類名調用靜態成員函數return 0;
}

在以上示例中，getStaticVar()和setStaticVar()都是靜態成員函數，可以直接通過類名來調用。靜態成員函數可以用于訪問和操作靜態數據成員，而不依賴于具體的對象實例。

六、友元機制

友元機制是C++中一種特殊的訪問權限控制機制，它允許一個類或函數訪問另一個類的私有成員。

在C++中，可以使用friend關鍵字將一個函數或類聲明為友元。被聲明為友元的函數或類可以直接訪問其它類的私有和保護成員，而不受訪問權限的限制。

6.1 友元函數

友元函數是指被聲明為某個類的友元的函數，可以訪問該類的私有成員和保護成員。通過友元函數，可以實現一些與該類有關的操作，即使這些操作不屬于該類的成員函數。

以下是一個友元函數的示例：

class MyClass {
private:int privateData;public:MyClass(int data) : privateData(data) {}friend int friendFunction(MyClass& obj);
};int friendFunction(MyClass& obj) {// 友元函數可以訪問私有成員return obj.privateData;
}int main() {MyClass myObj(5);int data = friendFunction(myObj);cout << "Private data: " << data << endl;return 0;
}

在上述示例中，MyClass類聲明了一個友元函數friendFunction()，并將其聲明為友元。friendFunction()函數可以訪問MyClass的私有成員privateData。

在main()函數中，我們創建了一個MyClass對象myObj，并將其初始化為5。然后調用friendFunction()函數，該函數訪問了myObj的私有成員privateData并返回它。最后，我們將返回的私有數據打印到控制臺上。

通過友元函數，我們可以方便地訪問類的私有成員，但同樣需要謹慎使用，以保護數據的封裝性。

6.2 友元類

友元類是指一個類被聲明為另一個類的友元，可以訪問該類的私有成員和保護成員。這樣，友元類可以在其成員函數中訪問被友元類的私有成員。

以下是一個友元類的示例：

class FriendClass {
private:int privateData;public:FriendClass(int data) : privateData(data) {}friend class MyClass;
};class MyClass {
public:void accessPrivateData(FriendClass& obj) {// 友元類可以訪問私有成員int data = obj.privateData;cout << "Private data: " << data << endl;}
};int main() {FriendClass friendObj(5);MyClass myObj;myObj.accessPrivateData(friendObj);return 0;
}

在上述示例中，FriendClass類被聲明為MyClass類的友元類。因此，在MyClass類中的成員函數accessPrivateData()中，可以訪問FriendClass類的私有成員privateData。

在main()函數中，我們創建了一個FriendClass對象friendObj，并將其初始化為5。然后，我們創建了一個MyClass對象myObj，并調用其成員函數accessPrivateData()，將friendObj作為參數傳遞給它。accessPrivateData()函數可以訪問friendObj的私有成員privateData，并將其打印到控制臺上。

通過友元類，類之間的訪問限制可以得到打破，但同樣需要謹慎使用，以保護數據的封裝性。

七、類的組合

在C++中，類的組合是指一個類包含另一個類的對象作為其成員。通過組合，一個類可以使用另一個類的功能，并將其封裝在自己的實現中。

組合是一種常用的實現方式，它允許類之間建立關聯關系，并共享彼此的功能。通過組合，我們可以構建更加復雜和靈活的類結構。

下面是一個示例，展示了如何在C++中使用類的組合：

// 定義一個矩形類
class Rectangle {
private:int width;int height;public:Rectangle(int w, int h) {width = w;height = h;}int calculateArea() {return width * height;}
};// 定義一個房間類，使用矩形類的對象作為成員
class Room {
private:Rectangle area;int numOfWindows;public:Room(int w, int h, int windows) : area(w, h) {numOfWindows = windows;}int calculateTotalArea() {return area.calculateArea() * numOfWindows;}
};int main() {// 創建一個房間對象Room myRoom(10, 12, 4);// 計算房間的總面積int totalArea = myRoom.calculateTotalArea();// 輸出結果cout << "Total area of the room: " << totalArea << endl;return 0;
}

在上面的示例中，Rectangle類表示一個矩形，它有一個calculateArea方法來計算矩形的面積。Room類表示一個房間，它有一個calculateTotalArea方法來計算房間的總面積，通過將Rectangle類的對象作為成員變量area來實現矩形的組合。通過創建一個Room對象，我們可以調用其方法來計算房間的總面積。

八、數據成員的初始化和釋放順序

在C++中，類的數據成員的初始化和釋放順序是按照它們在類中的聲明順序確定的。初始化順序是在進入構造函數的初始化列表之前確定的，而釋放順序是在析構函數中完成的；通過使用初始化列表，在構造函數中可以確保數據成員正確初始化。而在析構函數中，數據成員的釋放順序與初始化順序相反。

下面是一個示例，展示了數據成員初始化和釋放順序的規則：

class MyClass {
private:int x;int y;int z;public:MyClass(int a, int b, int c) : x(a), y(b), z(c) {// 構造函數}~MyClass() {// 析構函數}
};

在上面的示例中，MyClass類有三個整型數據成員：x、y和z。在構造函數中，我們使用初始化列表來初始化這些成員變量，按照它們在類中的聲明順序：先初始化x，然后是y，最后是z。在析構函數中，成員變量的釋放順序與初始化順序相反，先釋放z，然后是y，最后是x。

注意：

• 如果一個數據成員是一個對象或者指向一個對象的指針，在構造函數中如果需要使用它，那么它必須在初始化列表中進行初始化。

九、常對象與常成員

9.1 常對象

常對象是指被聲明為const的對象，即對象的值在創建后就不能被修改。

常對象的定義方法：

• 在對象聲明時直接加上const關鍵字。

const ClassName obj; // 聲明一個常對象

• 使用類型別名或引用來聲明常對象。

typedef const ClassName CObj; // 聲明一個常對象的類型別名CObj
CObj obj; // 聲明一個常對象

常對象的特點如下：

1. 常對象的狀態是只讀的，無法通過任何途徑修改其成員變量的值。
2. 常對象只能調用其類中被聲明為const的成員函數，不能調用非const成員函數。
3. 常對象可以調用常成員函數，因為常成員函數不會修改任何成員變量的值。

常對象在實際編程中有很多用途，例如：

• 在函數中傳遞常對象作為參數，以防止函數修改對象的值。
• 在類的成員函數中，常對象可以被用作參數或返回值，以保證函數的純粹性。
• 常對象可以用于實現單例模式中的只讀實例。

通過使用常對象，可以提高程序的安全性和可維護性，避免對象值的意外修改。

9.2 常成員

9.2.1 常成員函數

常成員函數指的是在類中聲明的成員函數加上const關鍵字，表示該函數不會修改對象的狀態。常成員函數可以被常對象調用，確保對象在調用該函數時不會被修改。

常成員函數的定義方式：

class ClassName {
public:void functionName() const;
};

在函數聲明后加上const關鍵字，表示該函數是一個常成員函數。常成員函數可以在類的內部或外部進行定義。

常成員函數的特點如下：

• 常成員函數不能修改對象的非常量數據成員。它只能讀取數據成員的值，而不能修改它們。
• 常成員函數只能調用其他常成員函數，而不能調用非常成員函數。這是為了保證在常成員函數中不會修改對象的狀態。

9.2.2 常成員數據

常成員數據指的是在類中聲明的成員變量加上const關鍵字，表示該變量的值在對象創建后就不能被修改。常成員數據必須在類的構造函數初始化列表中進行初始化。

常成員數據的定義方式為：

class ClassName {
private:const int variableName;
public:ClassName(int value) : variableName(value) {}
};

在成員變量的類型前加上const關鍵字，表示該變量是一個常成員數據。在構造函數初始化列表中對常成員數據進行初始化。

常成員數據的特點如下：

• 常成員數據的值在對象創建后就不能被修改，它們被視為對象的常量。
• 常成員數據只能在構造函數的初始化列表中進行初始化，而不能在構造函數內部或其他成員函數中進行修改。