一、定義：

　　當(dāng)object產(chǎn)生，有一個特殊的稱為constructor的函數(shù)會自動執(zhí)行。當(dāng)object死亡，有一個特殊的稱為destructor的函數(shù)會自動執(zhí)行。Constructor 可以不只一個，但 destructor 只能有一個。

　　Constructor（構(gòu)造函數(shù)）就是與class同名的那些member functions，例如CPoint::CPoint()或CDemo::CDemo()。Constructors不能夠指定返回值類型，也就是它不必（但可以）return。constructions可以有一個或多個，各有不同類型的參數(shù)。

　　Destructor（析構(gòu)函數(shù)）就是與class同名，且前面有加“~”符號的那個member function，例如例如 CPoint::~CPoint() 或 CDemo::~CDemo()。Destructor 不能指定返回值類型，也就是它不必（但可以）return。每個class只有一個destructor，并且不能有任何參數(shù)。

　　由于global object的誕生比程序進(jìn)入更早點，所以global object的constructor執(zhí)行的時間更早于程序的進(jìn)入點。

二、Default Constructors

　　所謂的default constructor就是沒有指定任何的參數(shù)的constructor。如果我們的class CA聲明如下：

#include <iostream>
using namespace std;
class CA
{
 public:
    int getdata(){return _data;};
    CA(){_data =5;};
    CA(int val){_data =val;};
 protected:
    int _data;
};

　　CA有兩個constructors，分別是CA(int) 和 CA()。后都沒有參數(shù)，正是所謂的default constructor。當(dāng)我產(chǎn)生一個 CA object 而沒有指定任何參數(shù)：

 CA aCA;
 CA* pCA = new CA;

　　編譯器就為我們呼叫default constructor。

　　普遍存在于C++程序員之間的一個誤解是：如果我們沒有為某個class設(shè)計constructor，編譯器會自動為該class制造出一個default constructor來。這個說法也對也不對，這里我先提示一個結(jié)論，銷稍后有更多細(xì)節(jié)探討。什么是編譯器所需要的動作？就是隱藏在C++程序代碼下面，讓C++諸多特征得到實現(xiàn)的動作，包含以下三種情況：

　　1. class CA 內(nèi) 含 class CZ objects，如圖1：當(dāng)產(chǎn)生一個CA object 時，隱藏在底層的必要動作是先初始化CZ object（因為CA object中有一個CZ object）

　　2.class CA繼承于class CZ，如圖2：當(dāng)產(chǎn)生一個CA object 時，隱藏在底層的必要動作是先調(diào)用CZ的default constructor （因為CA object中有一個CZ subobject）

　　3.CA是一個 polymorphic class,也就是說它有virtual functions，或繼承于有virtual functions的class。當(dāng)產(chǎn)生一個CA object，隱藏在底層的必要動作是：將虛擬機(jī)制所需要的vptr和vtb1初始化。

　　由于這三種情況皆有所謂的“底層的必要動作”，所以編譯器必須自動為class CA生成一個default constructor(（如果沒有任何 user-defined constructor 的話），或暗中對已有的user-defined constructor 動作腳（添加一些代碼）。生成出來的東西稱為“implicit nontrivial default constructor”。

　　如果沒有上述需求，編譯器就不會為class產(chǎn)生一個default constructor,例如： 

class CB
{ public:
int getdata() { return _data; };
protected:
int _data;
};

virtual functions的base classes），也沒有內(nèi)含embedded objects，也沒有繼承于其它class，所以編譯器不會為它生成一個default constructor出來，于是當(dāng)我們這么做：

 CB aCB; // 應(yīng)該調(diào)用default constructor
 cout << "aCB.getdata()=" << aCB.getdata() << endl;

　　但得到的結(jié)果如下：

aCB.getdata()=4211382 // 莫名其妙的初值

　　這個恐怕不是我所期望的，我們期望的_data有個初始值，但這個不是編譯器的需求，所以我們只能自求多福，自已設(shè)計一個default constructor:

 class CB
 { public:
     int getdata() { return _data; };
         CB() { _data = 5; }; // default constructor
 protected:
     int _data;
 };

　　現(xiàn)在輸出的結(jié)果就是我們所期望的了：

CB aCB; // 應(yīng)該調(diào)用  default constructor
cout << "aCB.getdata()=" << aCB.getdata() << endl;
// 輸出結(jié)果：aCB.getdata()=5

　　注意，如果class已經(jīng)有了任何constructor，但不是default constructor,編譯器絕不會為它生成一個default constructor。如果class CZ正是如此一個class，那么當(dāng)你想產(chǎn)生一個CZ object，并且沒有指定參數(shù)時：

CZ *aCZ; // error

　　編譯器會輸出異常提示：

error C2512: 'CZ' : no appropriate default constructor available

三、Copy Constructors

　　所謂的Copy Constructors是指有一個參數(shù)的類型是其 class type的 constructor，例如：

class CA
{
public:
    int getdata() {return _data; };     //default constructor
    CA(){_data =5;};
    CA(int val){_data=val; };           //constructor
    CA(const CA& ca){                  //copy constructor
        cout<<"copy constructor"<<endl;
        _data=10;
    };
protected:
    int _data;
};

 　　以下兩種情況，會喚起copy constructor：

　　情況1：將一個object當(dāng)做參數(shù)傳給某一個函數(shù)；

　　情況2：將一個object當(dāng)做函數(shù)的返回值；

　　例如（沿用上面的class CA）：

#include <iostream>
using namespace std;
class CA
{
public:
    int getdata() {return _data; };     //default constructor
    CA(){_data =5;};
    CA(int val){_data=val; };           //constructor
    CA(const CA& ca){                  //copy constructor
        cout<<"copy constructor"<<endl;
        _data=10;
    };
protected:
    int _data;
};
void foo2(CA aCA)//情況1（函數(shù)參數(shù)是個object）
{
    cout<<"in foo2(),aCA.getdata()="<<aCA.getdata()<<endl;
}
CA foo3()//情況2（函數(shù)的返回值是個object）
{
    CA aCA(3);
    cout<<"in foo3(),aCA.getdata()="<<aCA.getdata()<<endl;
    return aCA;
}
int main()
{
    CA aCA1,aCA2(7);
    cout << "aCA1.getdata()="<<aCA1.getdata()<< endl;
    cout << "aCA2.getdata()="<<aCA2.getdata()<< endl;
    aCA2 =aCA1;//object assignment
    cout << "aCA2.getdata()="<<aCA2.getdata()<< endl;
    foo2(aCA1);//情況1（調(diào)用之前aCA1._data 為5）
    aCA2=foo3();
    cout << "aCA2.getdata()="<<aCA2.getdata()<< endl;
    return 0;
}

　　讓我們看看執(zhí)行結(jié)果：

aCA1.getdata()=5
aCA2.getdata()=7
aCA2.getdata()=5 // 經(jīng)過 object assignment 之后
copy constructor
in foo2(), aCA.getdata()=10 // 經(jīng)過情況 1 之后
in foo3(), aCA.getdata()=3
copy constructor
aCA2.getdata()=10 // 經(jīng)過情況 2 之后

　　這里有幾點需要注意的：

　　1. 38行的將一個object指派（assign）給另一個object，這也是一種復(fù)制，但它喚起的所謂的copy assignment operator。本例并沒有特別設(shè)計copy assignment operator；

　　2.調(diào)用foo2（）之前，_data為5，進(jìn)入foo2（）之后再輸出，已變成10，可見copy constructor的確在foo2（）的參數(shù)復(fù)制時發(fā)生；

　　3.foo3（）內(nèi)有一個local object，其_data為3，把穹當(dāng)做返回值輸出，卻變成了10，可見copy constructor的確在foo3（）的返回值復(fù)制時發(fā)生；

到此這篇關(guān)于C++ 構(gòu)造函數(shù)和析構(gòu)函數(shù)(Constructors & Destructors)詳解的文章就介紹到這了,更多相關(guān)C++ 構(gòu)造函數(shù)和析構(gòu)函數(shù)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論