構造函數(shù)

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

構造函數(shù)的定義

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

構造函數(shù)的聲明格式如下：

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

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

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

//方式一
//使用帶入的參數(shù)值通過初始化列表為各成員變量賦初值
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已經(jīng)聲明了下列4個構造函數(shù)：

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

在類體外定義構造函數(shù)

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;
}

構造函數(shù)的使用

C++語言規(guī)定，創(chuàng)建類的任何對象時都一定會調(diào)動構造函數(shù)進行初始化。對象需要占據(jù)內(nèi)存空間，生成對象時，為對象分配的這段內(nèi)存空間的初始化由構造函數(shù)完成。

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

復制構造函數(shù)與類型轉換構造函數(shù)

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

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

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

例如：

//復制構造函數(shù)
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;
}

自動調(diào)用復制構造函數(shù)的情況有以下3種：

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

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

析構函數(shù)

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

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

類的靜態(tài)成員

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

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

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

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

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

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

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

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

• 給靜態(tài)成員變量賦初值的格式如下：

  類型 類名::靜態(tài)成員變量 = 初值;
  

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

訪問靜態(tài)成員時，成員前面既可以用類名作前綴，也可以使用對象名或?qū)ο笾羔樧髑熬Y。這與訪問類成員時僅能使用對象名或?qū)ο笾羔樧髑熬Y是不同的。

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

類的靜態(tài)成員函數(shù)沒有this指針，不能在靜態(tài)成員函數(shù)內(nèi)訪問非靜態(tài)的成員，即通常情況下，類的靜態(tài)成員函數(shù)只能處理類的靜態(tài)成員變量。驚天成員函數(shù)內(nèi)也不能調(diào)用非靜態(tài)成員函數(shù)。

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

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

變量的生存期和作用域

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

類對象的生存期和作用域

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

常量成員和常引用成員

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

  const 數(shù)據(jù)類型 常量名 = 表達式;
  

• 定義常量函數(shù)的格式如下：

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

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

例如：

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

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

成員對象和封閉類

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

封閉類構造函數(shù)的初始化列表

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

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

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

先調(diào)用成員對象的構造函數(shù)，再調(diào)用封閉類對象的構造函數(shù)。

封閉類的復制構造函數(shù)

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

友元

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

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

友元函數(shù)

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

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

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

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

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

//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 << "從友元函數(shù)中輸出：" << endl;
    t.printP(p1);//test:x = 0, y = 0
    t.printP(p2);//test:x = 10, y = 10
    
    return 0;
}

友元類

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

friend class 類名;

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

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

this指針

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