構造函數

• 為了對對象進行初始化，c++提供了一種稱為構造函數的機制，用于對對象進行初始化，實際上是用來為成員變量賦初值的。
• 構造函數是類中的特殊成員函數，它屬于類的一部分。給出類定義時，由程序員編寫構造函數。如果程序員沒有編寫類的任何構造函數，則由系統自動添加一個不帶參數的構造函數。
• 聲明對象后，可以使用new運算符為對象進行初始化，此時調用的是對象所屬類的構造函數。構造函數的作用是完成對象的初始化工作，用來保證對象的初始狀態是確定的。在對象生成時，系統自動調用構造函數，用戶在程序中不會直接調用構造函數。

構造函數的定義

定義一個類時，需要為類定義相應的構造函數。構造函數的函數名與類名相同，沒有****返回值****。一個類的構造函數可以有多個，即****構造函數允許重載。同一個類的多個構造函數的參數表一定不能完全相同。

構造函數的聲明格式如下：

類名(形參1, 形參2, ..., 形參n);

• 在聲明類的構造函數時可以同時給出函數體，這樣的構造函數稱為內聯函數。也可以在類體外給出構造函數的定義。構造函數的聲明中，形參的個數可以為0，即參數表為空。
• 當類中沒有定義任何構造函數時，系統會自動添加一個參數表為空、函數體也為空的構造函數，稱為默認構造函數。所以任何類都可以保證至少有一個構造函數。
• 如果程序員在程序中已經定義了構造函數，則系統不會再添加默認構造函數。

假設類的成員變量有三個，則在類體外定義構造函數時通常有如下3中形式：

//方式一
//使用帶入的參數值通過初始化列表為各成員變量賦初值
Student::Student(int sno, int age, string name):_sno(sno), _age(age), _name(name) {
    
}
//或者
//使用固定值在初始化列表中為個成員變量賦初值
Student::Student():_sno(11111), _age(13), _name("slh") {

}

//方式二
Student::Student(int sno, int age, string name) {
    _sno = sno;
    _age = age;
    _name = name;
}

//方式三
Student::Student() {
    _sno = 12345;
    _age = 12;
    _name = "tyg";
}

再比如類Student已經聲明了下列4個構造函數：

class Student {
public:
    Student();
    Student(int);
    Student(int, int);
    Student(int, int, string);
    void printStudent();
private:
    int _sno;
    int _age;
    string _name;
};

在類體外定義構造函數

Student::Student():_sno(12321), _age(23), _name("df") {
    
}
Student::Student(int sno):_age(12), _name("dfs") {
    _sno = sno;
}
Student::Student(int sno, int age):_name("dsf") {
    _sno = sno;
    _age = age;
}
Student::Student(int sno, int age, string name) {
    _sno = sno;
    _age = age;
    _name = name;
}

構造函數的使用

C++語言規定，創建類的任何對象時都一定會調動構造函數進行初始化。對象需要占據內存空間，生成對象時，為對象分配的這段內存空間的初始化由構造函數完成。

特別地，如果程序中聲明了對象數組，即數組的每個元素都是一個對象，則一定要為對象所屬的這個類定義一個無參的構造函數。因為數組中每個元素都需要調用無參的構造函數進行初始化，所以必須要有一個不帶參數的構造函數。

復制構造函數與類型轉換構造函數

復制構造函數是構造函數的一種，也稱為拷貝構造函數。它的作用是使用一個已存在的對象去初始化另一個正在創建的對象。例如，類對象間的賦值是由復制構造函數實現的。

復制構造函數只有一個參數，參數類型是****本類的引用。復制構造函數的參數可以是const引用，也可以是非const引用。一個類中可以寫兩個復制構造函數，一個函數的參數是const引用，另一個函數的參數是非const引用。這樣，當調用復制構造函數時，既能以常量對象（初始化后值不能改變的對象）作為參數，也能以非常量對象作為參數去初始化其他對象。對于類A而言，復制構造函數的原型如下：

//格式一
A::A(const A &)
//格式二
A::A(A &)

例如：

//復制構造函數
Student::Student(Student &s) {
    _sno = s._sno;
    _age = s._age;
    _name = s._name;
}
Student::Student(const Student &s) {
    _sno = s._sno;
    _age = s._age;
    _name = s._name;
}

自動調用復制構造函數的情況有以下3種：

1. 當用一個對象去初始化本類的另一個對象時，會調用復制構造函數。例如，使用下列形式的說明語句時，即會調用復制構造函數。
   1. 類名 對象名2(對象名1);
   2. 類名 對象名2 = 對象名1;
2. 如果函數F的參數是類A的對象，那么當調用F時，會調用類A的復制構造函數。換句話說，作為形參的對象，是用復制構造函數初始化的，而且調用復制構造函數時的參數，就是調用函數時所給的實參。
3. 如果函數的返回值是類A的對象，那么當函數返回時，會掉用類A的復制構造函數。也就是說，作為函數返回值的對象是用復制構造函數初始化的，而調用復制構造函數時的實參，就是return語句所返回的對象。

注意：
在復制構造函數的參數表中，加上const是更好的做法。這樣復制構造函數才能接收常量對象作為參數，即才能以常量對象作為參數去初始化別的對象。

析構函數

• 與構造函數一樣，析構函數也是成員函數的一種，它的名字也與類名相同，但要在類名前面加一個~字符，以區別于構造函數。析構函數沒有參數，也沒有返回值。一個類中有且僅有一個析構函數，如果成員中沒有定義析構函數，則編譯器自動生成默認的析構函數。析構函數不可以多于一個，不會有重載的析構函數。默認析構函數的函數體為空。
• 創建對象時自動調用構造函數，那么，什么時候調用析構函數呢？可想而知，在對象消亡時自動調用析構函數。析構函數的作用是做一些善后處理的工作。例如，如果在創建對象時使用new運算符動態分配了內存空間，則在析構函數中應該使用delete釋放掉這部分占用的空間，保證空間可再利用。
• 當使用new運算符生成對象指針時，自動調用本類的構造函數。使用delete刪除這個對象時，首先為這個動態對象調用本類的析構函數，然后再釋放這個動態對象占用的內存。

Student::~Student() {
    cout << "student對象被釋放了" << endl;
}

類的靜態成員

• 與C語言一樣，可以使用static說明自動變量。根據定義的位置不同，分為靜態全局變量和靜態局部變量。

• 全局變量是指在所有花括號之外聲明的變量，其作用域范圍是全局可見的，即在整個項目文件內都有效。使用static修飾的全局變量是靜態全局變量，其作用域有所限制，僅在定義該變量的源文件內有效，項目中的其他源文件中不能使用它。

• 塊內定義的變量是局部變量，從定義之處開始到本塊結束處為止是局部變量的作用域。使用static修飾的局部變量是靜態局部變量，即定義在塊中的靜態變量。靜態局部變量具有局部作用域，但卻具有全局生存期。

• 靜態局部變量具有局部作用域，但卻具有全局生存期。也就是說，靜態局部變量在程序的整個運行期間都存在，它占據的空間一直到程序結束時才釋放，但僅在定義它的塊中有效，在塊外并不能訪問它。

• 靜態變量均存儲在全局數據區，靜態局部變量只執行一次初始化。如果程序未顯式給出初始值，則相當于初始化為0；如果顯式給出初始值，則在該靜態變量所在塊第一次執行時完成初始化。

• 類的靜態成員有兩種：靜態成員變量和靜態成員函數。在類體內定義類的成員時，在前面添加static關鍵字后，該成員即成為靜態成員。

• 類的靜態成員被類的所有對象共享，不論有多少對象存在，靜態成員都只有一份保存在公用內存中。對于靜態成員變量，各對象看到的值是一樣的。

• 定義類靜態成員變量時，在類定義中聲明靜態成員變量，然后必須在類體外定義靜態成員變量的初值。這個初值不能在類體內賦值。

• 給靜態成員變量賦初值的格式如下：

  類型 類名::靜態成員變量 = 初值;
  

注意：
在類體外為靜態成員變量賦初值時，前面不能加static關鍵字，以免和一般的靜態變量想混淆。在類體外定義成員函數時，前面也不能加static關鍵字。

訪問靜態成員時，成員前面既可以用類名作前綴，也可以使用對象名或對象指針作前綴。這與訪問類成員時僅能使用對象名或對象指針作前綴是不同的。

//訪問類靜態成員的一般格式如下：
類名::靜態成員名
//或者
對象名.靜態成員名
//或者
對象指針->靜態成員名

類的靜態成員函數沒有this指針，不能在靜態成員函數內訪問非靜態的成員，即通常情況下，類的靜態成員函數只能處理類的靜態成員變量。驚天成員函數內也不能調用非靜態成員函數。

• 對于普通成員變量，每個對象有各自的一份，而****靜態成員變量只有一份，被同類所有對象共享。
• 普通成員函數一定是作用在某個對象上的，而靜態成員函數并不具體作用在某個對象上。
• 訪問普通成員時，要通過對象名.成員名等方式，指明要訪問的成員變量是屬于哪個對象的，或要調用的成員函數作用于哪個對象；
• 訪問靜態成員時，則可以通過類名::成員名的方式訪問，不需要指明被訪問的成員屬于哪個對象或作用于哪個對象。因此，甚至可以在還沒有任何對象生成時就訪問一個類的靜態成員。
• 非靜態成員的訪問方式其實也適用于靜態成員，也就是可以通過對象名.成員名的方式訪問，效果和類名::成員名這種訪問方式沒有區別。

變量及對象的生存期和作用域

變量的生存期和作用域

• 變量的生存期是指變量所占據的內存空間由分配到釋放的時期。變量有效的范圍稱為其作用域。全局變量是程序中定義在所有函數（包括main函數）之外的任何變量，其作用域是程序從變量定義到整個程序結束的部分。這意味著全局變量可以被所有定義在全局變量之后的函數訪問。全局變量及靜態變量分配的空間在全局數據區，它們的生存期為整個程序的執行期間。
• 而局部變量，如在函數內或程序塊內說明的變量，被分配到局部數據區，如棧區等。這種分配是臨時的，一旦該函數體或程序塊運行結束，所分配的空間就會被撤銷。局部變量的生存期從被說明處開始，到所在程序塊結束處結束。
• 對于靜態變量，如果沒有進行初始化，系統會自動初始化為0。局部變量如果沒有進行初始化，則其值是不確定的。
• 使用new運算符創建的變量具有動態生存期。從聲明處開始，直到用delete運算符釋放存儲空間或程序結束時，變量生存期結束。

類對象的生存期和作用域

類的對象在生成時調用構造函數，在消亡時調用析構函數，在這兩個函數調用之間即是對象的生存期。

常量成員和常引用成員

• 在類中，也可以使用const關鍵字定義成員變量和成員函數，甚至是類的對象。由關鍵字const修飾的類成員變量稱為類的常量成員變量。類的常量成員變量必須進行初始化，而且只能通過構造函數的成員初始化列表的方式進行。使用const修飾的函數稱為常量函數。定義類的對象時如果在前面添加const關鍵字，則該對象稱為常量對象。定義常量對象或常量成員變量的一般格式如下：

  const 數據類型 常量名 = 表達式;
  

• 定義常量函數的格式如下：

  類型說明符 函數名(參數表) const;
  

• 在對象被創建以后，其常量成員變量的值就不允許被修改，只可以讀取其值。對于常量對象，只能調用常量函數。總之，常量成員變量的值不能修改，常量對象中的各個屬性值均不能修改。

例如：

class CDemo {
public:
    void setValue(){};//非常量成員函數
}

int main() {
    const CDemo obj;//obj是常量對象
    obj.setValue();//?
    
    return 0;
}

成員對象和封閉類

一個類的成員變量如果是另一個類的對象，則該成員變量稱為成員對象。這兩個類為包含關系。包含成員對象的類焦作封閉類。

封閉類構造函數的初始化列表

當生成封閉類的對象并進行初始化時，它包含的成員對象也需要被初始化，需要調用成員對象的構造函數。在定義封閉類的構造函數時，需要添加初始化列表，指明要調用成員對象的哪個構造函數。在封閉類構造函數中添加初始化列表的格式如下：

封閉類名::構造函數名(參數表):成員變量1(參數表), 成員變量2(參數表), ... { ... }

初始化列表中的成員變量既可以是成員對象，也可以是基本數據類型的成員變量。對于成員對象，初始化列表的參數表中列出的是成員對象構造函數的參數（它指明了該成員對象如何初始化）。

先調用成員對象的構造函數，再調用封閉類對象的構造函數。

封閉類的復制構造函數

如果封閉類的對象是用默認復制構造函數初始化的，那么它包含的成員對象也會用復制構造函數初始化。

友元

友元實際上并不是面向對象的特征，而是為了兼顧C語言程序設計的習慣與C++信息隱藏的特點，而特意增加的功能。友元的概念破壞了類的封裝性和信息隱藏，但有助于數據共享，****能夠提高程序執行的效率。這是一種類成員的訪問權限。

友元使用關鍵字friend標識。在類定義中，當friend出現在函數說明語句的前面時，表示該函數為類的友元函數。一個函數可以同時說明為多個類的友元函數，一個類中也可以有多個友元函數。當friend出現在類名之前時，表示該類為類的友元類。

友元函數

在定義一個類的時候，可以把一些函數（包括全局函數和其他類的成員函數）聲明為友元，這樣那些函數就稱為本類的友元函數。在友元函數內部可以直接訪問本類對象的私有成員。在類定義中，將一個全局函數聲明為本類友元函數的格式如下：

friend 返回值類型 類名::類的成員函數名(參數表);

不能把其他類的私有成員函數聲明為友元函數。

友元函數不是類的成員函數，但允許訪問類中的所有成員。在函數體中訪問對象成員時，必須使用對象名.對象成員名的方式。

友元函數不受類中的訪問權限關鍵字限制，可以把它放在類的公有、私有、保護部分，結果是一樣的。

//Test.hpp
#include <stdio.h>

class Pixel;

class Test {
public:
    void printP(Pixel p);
    void printP(Pixel *p);
};

//Test.cpp
#include "Test.hpp"
#include "Pixel.hpp"

using namespace std;

void Test::printP(Pixel p) {
    cout << "test:x = " << p.x << ", y = " << p.y << endl;
}
void Test::printP(Pixel *p) {
    //?寫法
    //'x' is a private member of 'Pixel'
    //'y' is a private member of 'Pixel'
    cout << "x = " << p->x << ", y = " << p->y << endl;
}

//Pixel.hpp
#include <stdio.h>
#include <iostream>
#include "Test.hpp"

using namespace std;

class Pixel {
private:
    int x, y;
public:
    Pixel(int x0, int y0) {
        x = x0;
        y = y0;
    }
    void printXY() {
        cout << "x = " << x << ", y = " << y << endl;
    }
    friend double getDist(Pixel p1, Pixel p2);
    friend void Test::printP(Pixel p);
};

//main.cpp
#include <iostream>
#include <cmath>
#include "Test.hpp"
#include "Pixel.hpp"

using namespace std;

double getDist(Pixel p1, Pixel p2) {
    double xDist = double(p1.x - p2.x);
    double yDist = double(p1.y - p2.y);
    return sqrt(xDist * xDist + yDist * yDist);
}

int main(int argc, const char * argv[]) {
    
    Pixel p1(0, 0), p2(10, 10);
    p1.printXY();//x = 0, y = 0
    p2.printXY();//x = 10, y = 10
    cout << "p1和p2的間距 = " << getDist(p1, p2) << endl;
    //p1和p2的間距 = 14.1421
    
    Test t;
    cout << "從友元函數中輸出：" << endl;
    t.printP(p1);//test:x = 0, y = 0
    t.printP(p2);//test:x = 10, y = 10
    
    return 0;
}

友元類

如果將一個類B說明為另一個類A的****友元類，則類B中所有函數都是類A的友元函數，在類B的所有成員函數中都可以訪問類A中的所有成員。在類定義中聲明友元類的格式如下：

friend class 類名;

友元類的關系是****單向****的。若說明類B是類A的友元類，不等于類A也是類B的友元類。友元類的關系不能傳遞，即若類B是類A的友元類，而類C是類B的友元類，不等于類C是類A的友元類。

除非確有必要，一般不把整個類說明為友元類，而僅把類中的某些成員函數說明為友元函數。

this指針

• C++語言規定，當調用一個成員函數時，系統自動向它傳遞一個隱含的參數。該參數是一個指向調用該函數的對象的指針，稱為this指針，從而使成員函數知道對哪個對象進行操作。
• C++規定，在非靜態成員函數內部可以直接使用this關鍵字，this就代表指向該函數所作用的對象的指針。
• 在一般情況下，在不引起歧義時，可以省略this->，系統采用默認設置。
• 靜態成員是類具有的屬性，不是對象的特征，this表示的是隱藏的對象的指針，所以靜態成員函數沒有this指針。