C++類的構造函數、析構函數與指派函數

構造函數、析構函數與指派函數是每個類最基本的函數。它們太普通以緻讓人容易麻痹大意，其實這些貌似簡單的函數就象沒有頂蓋的下水道那樣危險。

       每個類隻有一個析構函數和一個指派函數，但可以有多個構造函數（包含一個拷貝構造函數，其它的稱為普通構造函數）。對于任意一個類A，如果不想編寫上述函數，C++編譯器将自動為A産生四個預設的函數，如

    A(void);                    // 預設的無參數構造函數

    A(const A &a);              // 預設的拷貝構造函數

    ~A(void);                   // 預設的析構函數

    A & operate =(const A &a);  // 預設的指派函數

這不禁讓人疑惑，既然能自動生成函數，為什麼還要程式員編寫？

原因如下：

（1）如果使用“預設的無參數構造函數”和“預設的析構函數”，等于放棄了自主“初始化”和“清除”的機會，C++發明人Stroustrup的好心好意白費了。

（2）“預設的拷貝構造函數”和“預設的指派函數”均采用“位拷貝”而非“值拷貝”的方式來實作，倘若類中含有指針變量，這兩個函數注定将出錯。

對于那些沒有吃夠苦頭的C++程式員，如果他說編寫構造函數、析構函數與指派函數很容易，可以不用動腦筋，表明他的認識還比較膚淺，水準有待于提高。

本章以類String的設計與實作為例，深入闡述被很多教科書忽視了的道理。String的結構如下：

    class String

    {

      public:

        String(const char *str = NULL); // 普通構造函數

        String(const String &other);    // 拷貝構造函數

        ~ String(void);                 // 析構函數

        String & operate =(const String &other);    // 指派函數

      private:

        char    *m_data;                // 用于儲存字元串

    };

1 構造函數與析構函數的起源

       作為比C更先進的語言，C++提供了更好的機制來增強程式的安全性。C++編譯器具有嚴格的類型安全檢查功能，它幾乎能找出程式中所有的文法問題，這的确幫了程式員的大忙。但是程式通過了編譯檢查并不表示錯誤已經不存在了，在“錯誤”的大家庭裡，“文法錯誤”的地位隻能算是小弟弟。級别高的錯誤通常隐藏得很深，想逮住他可不容易。

       根據經驗，不少難以察覺的程式錯誤是由于變量沒有被正确初始化或清除造成的，而初始化和清除工作很容易被人遺忘。Stroustrup在設計C++語言時充分考慮了這個問題并很好地予以解決：把對象的初始化工作放在構造函數中，把清除工作放在析構函數中。當對象被建立時，構造函數被自動執行。當對象消亡時，析構函數被自動執行。這下就不用擔心忘了對象的初始化和清除工作。

       構造函數與析構函數的名字不能随便起，必須讓編譯器認得出才可以被自動執行。Stroustrup的命名方法既簡單又合理：讓構造函數、析構函數與類同名，由于析構函數的目的與構造函數的相反，就加字首‘～’以示差別。

除了名字外，構造函數與析構函數的另一個特别之處是沒有傳回值類型，這與傳回值類型為void的函數不同。構造函數與析構函數的使命非常明确，就像出生與死亡，光溜溜地來光溜溜地去。如果它們有傳回值類型，那麼編譯器将不知所措。為了防止節外生枝，幹脆規定沒有傳回值類型。（以上典故參考了文獻[Eekel, p55-p56]）

2 構造函數的初始化表

       構造函數有個特殊的初始化方式叫“初始化表達式表”（簡稱初始化表）。初始化表位于函數參數表之後，卻在函數體 {} 之前。這說明該表裡的初始化工作發生在函數體内的任何代碼被執行之前。

       構造函數初始化表的使用規則：

1. 如果類存在繼承關系，派生類必須在其初始化表裡調用基類的構造函數。

例如

    class A

    {…

        A(int x);       // A的構造函數

}; 

    class B : public A

    {…

        B(int x, int y);// B的構造函數

    };

    B::B(int x, int y)

     : A(x)             // 在初始化表裡調用A的構造函數

    {

      …

}  

1. 類的const常量隻能在初始化表裡被初始化，因為它不能在函數體内用指派的方式來初始化（參見5.4節）。
2. 類的資料成員的初始化可以采用初始化表或函數體内指派兩種方式，這兩種方式的效率不完全相同。

    非内部資料類型的成員對象應當采用第一種方式初始化，以擷取更高的效率。例如

    class A

{…

    A(void);                // 無參數構造函數

    A(const A &other);      // 拷貝構造函數

    A & operate =( const A &other); // 指派函數

}；

    class B

    {

      public:

        B(const A &a);  // B的構造函數

      private: 

        A  m_a;         // 成員對象

};

示例9-2(a)中，類B的構造函數在其初始化表裡調用了類A的拷貝構造函數，進而将成員對象m_a初始化。

示例9-2 (b)中，類B的構造函數在函數體内用指派的方式将成員對象m_a初始化。我們看到的隻是一條指派語句，但實際上B的構造函數幹了兩件事：先暗地裡建立m_a對象（調用了A的無參數構造函數），再調用類A的指派函數，将參數a賦給m_a。

B::B(const A &a)  : m_a(a)           {    … }

B::B(const A &a) { m_a = a; … }

 示例9-2(a) 成員對象在初始化表中被初始化      示例9-2(b) 成員對象在函數體内被初始化

對于内部資料類型的資料成員而言，兩種初始化方式的效率幾乎沒有差別，但後者的程式版式似乎更清晰些。若類F的聲明如下：

class F

{

  public:

    F(int x, int y);        // 構造函數

  private:

    int m_x, m_y;

    int m_i, m_j;

}

示例9-2(c)中F的構造函數采用了第一種初始化方式，示例9-2(d)中F的構造函數采用了第二種初始化方式。

F::F(int x, int y)  : m_x(x), m_y(y)           {    m_i = 0;    m_j = 0; }

F::F(int x, int y) {    m_x = x;    m_y = y;    m_i = 0;    m_j = 0; }

 示例9-2(c) 資料成員在初始化表中被初始化     示例9-2(d) 資料成員在函數體内被初始化

3 構造和析構的次序

       構造從類層次的最根處開始，在每一層中，首先調用基類的構造函數，然後調用成員對象的構造函數。析構則嚴格按照與構造相反的次序執行，該次序是唯一的，否則編譯器将無法自動執行析構過程。

一個有趣的現象是，成員對象初始化的次序完全不受它們在初始化表中次序的影響，隻由成員對象在類中聲明的次序決定。這是因為類的聲明是唯一的，而類的構造函數可以有多個，是以會有多個不同次序的初始化表。如果成員對象按照初始化表的次序進行構造，這将導緻析構函數無法得到唯一的逆序。[Eckel, p260-261]

4 示例：類String的構造函數與析構函數

       // String的普通構造函數

       String::String(const char *str)

{

    if(str==NULL)

    {

        m_data = new char[1];

        *m_data = ‘\0’;

    }  

    else

    {

        int length = strlen(str);

        m_data = new char[length+1];

        strcpy(m_data, str);

    }

}  

// String的析構函數

       String::~String(void)

{

    delete [] m_data;  

// 由于m_data是内部資料類型，也可以寫成 delete m_data;

       }

5 不要輕視拷貝構造函數與指派函數

       由于并非所有的對象都會使用拷貝構造函數和指派函數，程式員可能對這兩個函數有些輕視。請先記住以下的警告，在閱讀正文時就會多心：

1. 本章開頭講過，如果不主動編寫拷貝構造函數和指派函數，編譯器将以“位拷貝”的方式自動生成預設的函數。倘若類中含有指針變量，那麼這兩個預設的函數就隐含了錯誤。以類String的兩個對象a,b為例，假設a.m_data的内容為“hello”，b.m_data的内容為“world”。

現将a賦給b，預設指派函數的“位拷貝”意味着執行b.m_data = a.m_data。這将造成三個錯誤：一是b.m_data原有的記憶體沒被釋放，造成記憶體洩露；二是b.m_data和a.m_data指向同一塊記憶體，a或b任何一方變動都會影響另一方；三是在對象被析構時，m_data被釋放了兩次。

1. 拷貝構造函數和指派函數非常容易混淆，常導緻錯寫、錯用。拷貝構造函數是在對象被建立時調用的，而指派函數隻能被已經存在了的對象調用。以下程式中，第三個語句和第四個語句很相似，你分得清楚哪個調用了拷貝構造函數，哪個調用了指派函數嗎？

String  a(“hello”);

String  b(“world”);

String  c = a;  // 調用了拷貝構造函數，最好寫成 c(a);

c = b; // 調用了指派函數

本例中第三個語句的風格較差，宜改寫成String c(a) 以差別于第四個語句。

6 示例：類String的拷貝構造函數與指派函數

    // 拷貝構造函數

    String::String(const String &other)

    {  

// 允許操作other的私有成員m_data

    int length = strlen(other.m_data); 

    m_data = new char[length+1];

    strcpy(m_data, other.m_data);

}

// 指派函數

    String & String::operate =(const String &other)

    {  

        // (1) 檢查自指派

        if(this == &other)

            return *this;

        // (2) 釋放原有的記憶體資源

        delete [] m_data;

        // （3）配置設定新的記憶體資源，并複制内容

    int length = strlen(other.m_data); 

    m_data = new char[length+1];

        strcpy(m_data, other.m_data);

        // （4）傳回本對象的引用

        return *this;

}  

    類String拷貝構造函數與普通構造函數（參見9.4節）的差別是：在函數入口處無需與NULL進行比較，這是因為“引用”不可能是NULL，而“指針”可以為NULL。

    類String的指派函數比構造函數複雜得多，分四步實作：

（1）第一步，檢查自指派。你可能會認為多此一舉，難道有人會愚蠢到寫出 a = a 這樣的自指派語句！的确不會。但是間接的自指派仍有可能出現，例如

// 内容自指派 b = a; … c = b; … a = c;

// 位址自指派 b = &a; … a = *b;

也許有人會說：“即使出現自指派，我也可以不理睬，大不了化點時間讓對象複制自己而已，反正不會出錯！”

他真的說錯了。看看第二步的delete，自殺後還能複制自己嗎？是以，如果發現自指派，應該馬上終止函數。注意不要将檢查自指派的if語句

if(this == &other)

錯寫成為

    if( *this == other)

（2）第二步，用delete釋放原有的記憶體資源。如果現在不釋放，以後就沒機會了，将造成記憶體洩露。

（3）第三步，配置設定新的記憶體資源，并複制字元串。注意函數strlen傳回的是有效字元串長度，不包含結束符‘\0’。函數strcpy則連‘\0’一起複制。

（4）第四步，傳回本對象的引用，目的是為了實作象 a = b = c 這樣的鍊式表達。注意不要将 return *this 錯寫成 return this 。那麼能否寫成return other 呢？效果不是一樣嗎？

不可以！因為我們不知道參數other的生命期。有可能other是個臨時對象，在指派結束後它馬上消失，那麼return other傳回的将是垃圾。

7 偷懶的辦法處理拷貝構造函數與指派函數

       如果我們實在不想編寫拷貝構造函數和指派函數，又不允許别人使用編譯器生成的預設函數，怎麼辦？

       偷懶的辦法是：隻需将拷貝構造函數和指派函數聲明為私有函數，不用編寫代碼。

例如：

    class A

    { …

      private:

        A(const A &a);              // 私有的拷貝構造函數

        A & operate =(const A &a);  // 私有的指派函數

    };

如果有人試圖編寫如下程式：

    A  b(a);    // 調用了私有的拷貝構造函數

    b = a;      // 調用了私有的指派函數

編譯器将指出錯誤，因為外界不可以操作A的私有函數。

8 如何在派生類中實作類的基本函數

       基類的構造函數、析構函數、指派函數都不能被派生類繼承。如果類之間存在繼承關系，在編寫上述基本函數時應注意以下事項：

1. 派生類的構造函數應在其初始化表裡調用基類的構造函數。
2. 基類與派生類的析構函數應該為虛（即加virtual關鍵字）。例如

#include <iostream.h>

class Base

{

  public:

    virtual ~Base() { cout<< "~Base" << endl ; }

};

class Derived : public Base

{

  public:

    virtual ~Derived() { cout<< "~Derived" << endl ; }

};

void main(void)

{

    Base * pB = new Derived;  // upcast

    delete pB;

}

輸出結果為：

       ~Derived

       ~Base

如果析構函數不為虛，那麼輸出結果為

       ~Base

1. 在編寫派生類的指派函數時，注意不要忘記對基類的資料成員重新指派。例如：

class Base

{

  public:

…

    Base & operate =(const Base &other);    // 類Base的指派函數

  private:

    int  m_i, m_j, m_k;

};

class Derived : public Base

{

  public:

…

    Derived & operate =(const Derived &other);  // 類Derived的指派函數

  private:

    int  m_x, m_y, m_z;

};

Derived & Derived::operate =(const Derived &other)

{

    //（1）檢查自指派

    if(this == &other)

        return *this;

    //（2）對基類的資料成員重新指派

    Base::operate =(other); // 因為不能直接操作私有資料成員

    //（3）對派生類的資料成員指派

    m_x = other.m_x;

    m_y = other.m_y;

    m_z = other.m_z;

    //（4）傳回本對象的引用

    return *this;

}