C++中常見的類特性

一、構造函數：初始化類成員

class MyClass {
public:
    MyClass(int value):m_value(value) {}
private:
    int m_value;
};

MyClass myObject(5);

構造函數用於初始化類的成員變數，在對象被創建時被自動調用。在上面的例子中，MyClass類的構造函數需要一個int類型的參數，並將它存儲在m_value成員變數中。當調用MyClass myObject(5)時，將創建一個名為myObject的MyClass類對象，其m_value成員變數的值為5。

二、析構函數：釋放類資源

class MyClass {
public:
    ~MyClass() { cout<<"Destructor called"<<endl; }
};

MyClass* myObject = new MyClass(); //創建對象
delete myObject;                   //釋放對象

析構函數用於釋放類所佔用的資源，在對象被銷毀時自動調用。在上面的例子中，MyClass類的析構函數沒有參數，且沒有任何實際作用，只是輸出一行信息。當使用new運算符創建一個MyClass類對象時，將為該對象分配內存，當使用delete運算符釋放該對象時，將自動調用MyClass類的析構函數來釋放該對象佔用的內存。

三、訪問器函數：獲取私有成員變數的值

class MyClass {
public:
    int getValue() const { return m_value; }
private:
    int m_value;
};

MyClass myObject;
int value = myObject.getValue(); //獲取m_value的值

訪問器函數也稱為getter函數，用於獲取類中私有成員變數的值。在上面的例子中，MyClass類定義了一個名為getValue的訪問器函數，該函數返回m_value成員變數的值。當調用myObject.getValue()時，將返回myObject對象的m_value成員變數的值。注意，該訪問器函數使用const關鍵字來表明它不修改對象。

四、修改器函數：修改私有成員變數的值

class MyClass {
public:
    void setValue(int value) { m_value = value; }
private:
    int m_value;
};

MyClass myObject;
myObject.setValue(10); //將m_value的值設置為10

修改器函數也稱為setter函數，用於修改類中私有成員變數的值。在上面的例子中，MyClass類定義了一個名為setValue的修改器函數，該函數將傳入的參數設置為m_value成員變數的值。當調用myObject.setValue(10)時，將設置myObject對象的m_value成員變數的值為10。

五、靜態成員變數：類級別的變數

class MyClass {
public:
    static int s_value;
};

int MyClass::s_value = 0;

MyClass myObject1;
MyClass myObject2;
myObject1.s_value = 5; //設置s_value的值為5
cout<<myObject2.s_value; //輸出5

靜態成員變數是屬於整個類的，所有該類的對象共享一個靜態成員變數。如上例中，MyClass類定義了一個靜態成員變數s_value，類內部沒有初始化它的值，需要在類外部進行初始化。當聲明多個MyClass類對象時，這些對象共享該靜態成員變數，可以通過任何一個對象對其進行修改，其他對象均會受到影響。

六、友元函數：訪問類的私有成員

class MyClass {
public:
    friend int getPrivateValue(MyClass obj); //聲明友元函數
private:
    int m_value;
};

int getPrivateValue(MyClass obj) { return obj.m_value; } //定義友元函數

MyClass myObject;
myObject.m_value = 10; //無法直接訪問m_value
int value = getPrivateValue(myObject); //使用友元函數獲取m_value的值

友元函數不是類成員函數，但是可以訪問類的私有成員。在上例中，MyClass類定義了一個名為getPrivateValue的友元函數，在函數內部可以訪問MyClass類的私有成員變數m_value。當需要訪問該成員變數時，可以通過調用getPrivateValue函數來實現。

七、常量成員函數：不修改成員變數的函數

class MyClass {
public:
    int getValue() const { return m_value; } //常量成員函數
private:
    int m_value;
};

MyClass myObject;
int value = myObject.getValue(); //調用常量成員函數

常量成員函數表示它不會修改類的任何成員變數，因此它被認為是一個「安全」函數。通過在函數末尾使用const關鍵字，可以將該函數聲明為常量成員函數。在上例中，MyClass類定義了一個名為getValue的常量成員函數，該函數不修改m_value成員變數的值。常量成員函數與訪問器函數的語法非常相似，它們都不允許修改類的成員變數。

八、虛函數：用於多態性的實現

class Animal {
public:
    virtual void speak() { cout<<"Animal"<<endl; } //虛函數
};

class Cat : public Animal {
public:
    void speak() { cout<<"Meow"<<endl; }
};

class Dog : public Animal {
public:
    void speak() { cout<<"Woof"<speak(); //輸出「Meow」

虛函數用於實現多態性，它可以讓程序在運行時動態調用適當的子類函數。在上例中，定義了一個虛函數speak，它是Animal類的成員函數，並在Cat和Dog子類中進行了重寫。當使用Animal*類型的指針指向Cat對象時，可以調用speak函數來輸出「Meow」，因為該對象是Cat類型的。

九、純虛函數：沒有實現的虛函數，需要由子類實現

class Animal {
public:
    virtual void speak() = 0; //純虛函數
};

class Cat : public Animal {
public:
    void speak() { cout<<"Meow"<speak(); //輸出「Meow」

純虛函數是一種虛函數，它沒有實現，需要由其子類進行實現。在Animal類中，定義了一個名為speak的純虛函數，它沒有任何實際的代碼實現。當創建一個子類，並從Animal類中繼承時，需要實現speak函數。在上面的例子中，Cat子類實現了speak函數，並可以被Animal類指針調用。

十、繼承：子類繼承父類的特性

class Animal {
public:
    void eat() { cout<<"I am eating"<<endl; }
};

class Cat : public Animal {
public:
    void meow() { cout<<"Meow"<<endl; }
};

Cat myCat;
myCat.eat();  // 輸出"I am eating"
myCat.meow(); // 輸出"Meow"

繼承允許子類繼承父類的特性，包括成員變數和成員函數。在上例中，Cat子類繼承了Animal父類的成員函數eat。當創建一個myCat對象時，可以調用它繼承的eat函數。

十一、多重繼承：子類繼承多個父類的特性

class Animal {
public:
    void eat() { cout<<"I am eating"<<endl; }
};

class Vehicle {
public:
    void drive() { cout<<"I am driving"<<endl; }
};

class CatBus : public Animal, public Vehicle {
public:
    void meow() { cout<<"Meow"<<endl; }
};

CatBus myCatBus;
myCatBus.eat();   // 輸出"I am eating"
myCatBus.drive(); // 輸出"I am driving"
myCatBus.meow();  // 輸出"Meow"

多重繼承允許子類同時繼承多個父類的特性。在上例中，CatBus子類同時繼承了Animal和Vehicle兩個父類的特性。當創建一個myCatBus對象時，可以調用它繼承的eat和drive函數。