面向對象編程：C++類和對象的使用與實現

一、C++類和對象的概述

C++是一種面向對象的編程語言，它側重於將現實世界中事物以及它們之間的關係，用模擬現實世界的方式進行抽象和描述，從而構建出更清晰、更易於維護的程序結構。

類(Class)是C++語言中的一個重要特徵，它是一種封裝了數據和行為的用戶定義數據類型，可以看作是自定義數據類型的模板，將數據和方法組織在一起，在程序中調用方法，可以對數據進行操作。

對象(Object)是類的實例化，它是具有唯一標識、屬性、行為的實體，是程序中類的使用者，通過對象可以訪問類中的成員。

class Student{        // 類定義，包含類名、數據成員、成員函數以及訪問控制
private:
    string name;
    int age;
public:
    void setAge(int a);      // 成員函數聲明
    int getAge();            // 成員函數聲明
};
void Student::setAge(int a){  // 成員函數定義
    age = a;
}
int Student::getAge(){         // 成員函數定義
    return age;
}
int main(){
    Student stu;            // 定義對象
    stu.setAge(18);         // 訪問成員函數設置年齡
    int age = stu.getAge(); // 訪問成員函數獲取年齡
}

二、C++類和對象中的訪問控制

封裝性是面向對象編程的一個主要原則，它可以保護數據不被程序的其他部分隨意更改，C++通過訪問控制關鍵字private、protected、public來實現類中成員的保護和控制訪問級別。

private：私有成員，只能在類的內部使用。

protected：受保護成員，只能在類及其子類中使用。

public：公共成員，可以在類的內部和外部使用。

class Student{
private:
    string name;      // 私有成員
protected:
    int age;          // 受保護成員
public:
    void setName(string n){ name = n; }
    string getName(){ return name; }
};
class Undergraduate : public Student{  // 繼承Student類
public:
    void setAge(int a){ age = a; }     // 在子類中通過調用父類的受保護函數設置年齡
    int getAge(){ return age; }        // 在子類中通過調用父類的受保護函數獲取年齡
};
int main(){
    Undergraduate ustu;
    ustu.setName("Tom");    // 調用公共成員函數設置name
    ustu.setAge(19);        // 調用受保護成員函數設置age
    string name = ustu.getName();   // 調用公共成員函數獲取name
    int age = ustu.getAge();        // 在子類中通過調用父類的受保護函數獲取年齡
}

三、C++類和對象中的構造和析構函數

構造函數和析構函數是C++類中兩個最為重要的函數，它們分別在對象創建和銷毀的時候被調用，可以對對象進行初始化和釋放資源等操作。

構造函數：與類同名，沒有返回類型，用來初始化對象的數據成員；如果程序員沒有定義構造函數，編譯器會自動生成一個默認構造函數，否則需要顯式定義。

析構函數：與類同名，以“~”開頭，沒有返回類型，用來釋放對象佔用的資源；如果程序員沒有定義析構函數，編譯器會自動生成一個默認析構函數，否則需要顯式定義。

class Student{
private:
    string name;
    int age;
public:
    Student();            // 默認構造函數
    Student(string n, int a);  // 帶參數的構造函數
    ~Student();           // 析構函數
    void setName(string n){ name = n; }
    string getName(){ return name; }
};
Student::Student(){     // 實現默認構造函數
    name = "";
    age = 0;
}
Student::Student(string n, int a){   // 實現帶參數的構造函數
    name = n;
    age = a;
}
Student::~Student(){    // 實現析構函數
    /* 釋放資源 */
}
int main(){
    Student stu1;                 // 調用默認構造函數
    Student stu2("Tom", 18);      // 調用帶參數的構造函數，初始化name和age
}

四、C++類和對象的靜態成員

靜態成員是一種特殊的成員，它不屬於任何對象，而是屬於整個類共享的。通過訪問類名::成員名的方式來訪問。

靜態數據成員：靜態的數據成員，與類的所有對象共用一個數據空間。

靜態成員函數：靜態的成員函數，與類的所有對象無關，只能訪問靜態數據成員和靜態成員函數，不可以訪問非靜態成員。

class Student{
private:
    string name;
    int age;
    static int count;    // 靜態數據成員
public:
    static void showCount();    // 靜態成員函數
    Student();
    ~Student();
};
int Student::count = 0;    // 靜態數據成員初始化
void Student::showCount(){    // 實現靜態成員函數
    cout << "The total number of students is: "<< count << endl;
}
Student::Student(){    // 實現構造函數
    count++;
}
Student::~Student(){   // 實現析構函數
    count--;
}
int main(){
    Student stu1, stu2;
    Student::showCount();    // 調用靜態成員函數
}

五、C++類和對象的拷貝構造函數和賦值運算符

拷貝構造函數和賦值運算符是C++類中的兩個重要函數，用來在對象之間進行拷貝，構造出新的獨立的對象。

拷貝構造函數：與類同名，它用於創建一個對象並將其初始化為另一個對象的副本；如果程序員沒有定義拷貝構造函數，編譯器會自動生成一個默認拷貝構造函數，否則需要顯式定義。

賦值運算符：以“=”為符號，用於將另一個對象的值複製到已有對象中。如果程序員沒有定義賦值運算符，編譯器會自動生成一個默認賦值運算符，否則需要顯式定義。

class Student{
private:
    string name;
    int age;
public:
    Student();
    Student(const Student& other);   // 拷貝構造函數
    Student& operator=(const Student& other);  // 賦值運算符
};
Student::Student(){    // 默認構造函數
    name = "";
    age = 0;
}
Student::Student(const Student& other){   // 拷貝構造函數
    name = other.name;
    age = other.age;
}
Student& Student::operator=(const Student& other){   // 賦值運算符
    if (this != &other){    // 判斷是否為同一對象
        name = other.name;
        age = other.age;
    }
    return *this;
}
int main(){
    Student stu1, stu2;
    stu1 = stu2;    // 賦值運算符調用
    Student stu3 = stu2;    // 拷貝構造函數調用
}