C++ 的構造/析構/賦值/拷貝函數比較

構造函數、析構函數與賦值函數是每個類最基本的函數。每個類只有一個析構函數，但可以有多個構造函數（包含一個拷貝構造函數，其它的稱爲普通構造函數）和 多個賦值函數（除了同類的賦值以外，還有其他的賦值方法）。對於任意一個類A，如果不想編寫上述函數，C++編譯器將自動爲A產生四個缺省的函數，如
A(void);                    // 缺省的無參數構造函數
A(const A &a);              // 缺省的拷貝構造函數
~A(void);                   // 缺省的析構函數
A & operate =(const A &a); // 缺省的賦值函數

有幾個需要注意的內容：
@ 構造函數與析構函數的另一個特別之處是沒有返回值類型
@ 構造從類層次的最頂層的基類開始，在每一層中，首先調用基類的構造函數，然後調用成員對象的構造函數。析構則嚴格按照與構造相反的次序執行，在析構的時候，最低層的派生類的析構函數最開始被調用，然後調用每個基類的析構函數。
@ “缺省的拷貝構造函數”和“缺省的賦值函數”均採用“位拷貝”而非“值拷貝”的方式來實現，倘若類中含有指針變量，這兩個函數註定將出錯

下面通過例子進一步說明，


1.構造函數的初始化表
設存在兩個類：

class A
{
     …
     A(void);                // 無參數構造函數
     A(const A &other);      // 拷貝構造函數
     A & operate =( const A &other);  // 賦值函數
    virtual ~A(void);        //析構函數
}；
class B
{
public:
     B(const A &a);    // B的構造函數

private:   
     A   m_a;            // 成員對象
};

下面面是B的構造函數的2個實現，其中第一個的類B的構造函數在其初始化表裏調用了類A的拷貝構造函數，從而將成員對象m_a初始化；而第二個的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;
     …
}

2.拷貝函數和構造函數的區別
拷貝構造函數是在對象被創建時調用的，而賦值函數只能被已經存在了的對象調用。
String a(“hello”);
String b(“world”);
String c = a; // 調用了拷貝構造函數，最好寫成 c(a);
c = b;            // 調用了賦值函數
本例中第三個語句的風格較差，宜改寫成String c(a) 以區別於第四個語句。

如果我們實在不想編寫拷貝構造函數和賦值函數，又不允許別人使用編譯器生成的缺省函數，可以將拷貝構造函數和賦值函數聲明爲私有函數，不用編寫代碼。


3.析構函數與虛析構函數
基類的構造函數、析構函數、賦值函數都不能被派生類繼承。如果類之間存在繼承關係，在編寫上述基本函數時應注意以下事項：
@ 派生類的構造函數應在其初始化表裏調用基類的構造函數
@ 基類與派生類的析構函數應該爲虛（即加virtual關鍵字）

#include <iostream>
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

示例說明：

編寫類String的構造函數，析構函數，賦值函數．

class String{

     public:

            String(const char *str=NULL);

            String(const String &other);

            ~String(void);

            String& operate = (const String &other);

     private:

            char * m_data;

};

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(const String &other){

           int length = strlen(other.m_data);

           m_data = new char[length+1];

           strcpy(m_data,other.m_data);

}

String::~String(void){

          delete [] m_data;

}

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

          if(this==&other)  //檢查自賦值．

                 return *this;

           delete [] m_data; //釋放原有的內存資源．

           int length = strlen(other.m_data);

           m_data = new char[length+1];

           strcpy(m_data,other.m_data);

            return *this;

}