C++拷貝構造函數詳解

一. 什麼是拷貝構造函數

首先對於普通類型的對象來說，它們之間的複製是很簡單的，例如：

int a = 100;
int b = a;

而類對象與普通對象不同，類對象內部結構一般較爲複雜，存在各種成員變量。
下面看一個類對象拷貝的簡單例子。

#include <iostream>
using namespace std;

class CExample {
private:
    　int a;
public:
      //構造函數
    　CExample(int b)
    　{ a = b;}

      //一般函數
    　void Show ()
    　{
        cout<<a<<endl;
      }
};

int main()
{
    　CExample A(100);
    　CExample B = A; //注意這裏的對象初始化要調用拷貝構造函數，而非賦值
    　 B.Show ();
    　return 0;
}

運行程序，屏幕輸出100。從以上代碼的運行結果可以看出，系統爲對象 B 分配了內存並完成了與對象 A 的複製過程。就類對象而言，相同類型的類對象是通過拷貝構造函數來完成整個複製過程的。

下面舉例說明拷貝構造函數的工作過程。

#include <iostream>
using namespace std;

class CExample {
private:
    int a;
public:
    //構造函數
    CExample(int b)
    { a = b;}

    //拷貝構造函數
    CExample(const CExample& C)
    {
        a = C.a;
    }

    //一般函數
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B = A; // CExample B(A); 也是一樣的
     B.Show ();
    return 0;
}

CExample(const CExample& C)　就是我們自定義的拷貝構造函數。可見，拷貝構造函數是一種特殊的構造函數，函數的名稱必須和類名稱一致，它必須的一個參數是本類型的一個引用變量。

二. 拷貝構造函數的調用時機

在C++中，下面三種對象需要調用拷貝構造函數！
1. 對象以值傳遞的方式傳入函數參數

class CExample
{
private:
 int a;

public:
 //構造函數
 CExample(int b)
 {
  a = b;
  cout<<"creat: "<<a<<endl;
 }

 //拷貝構造
 CExample(const CExample& C)
 {
  a = C.a;
  cout<<"copy"<<endl;
 }

 //析構函數
 ~CExample()
 {
  cout<< "delete: "<<a<<endl;
 }

     void Show ()
 {
         cout<<a<<endl;
     }
};

//全局函數，傳入的是對象
void g_Fun(CExample C)
{
 cout<<"test"<<endl;
}

int main()
{
 CExample test(1);
 //傳入對象
 g_Fun(test);

 return 0;
}

調用g_Fun()時，會產生以下幾個重要步驟：
(1).test對象傳入形參時，會先會產生一個臨時變量，就叫 C 吧。
(2).然後調用拷貝構造函數把test的值給C。 整個這兩個步驟有點像：CExample C(test);
(3).等g_Fun()執行完後, 析構掉 C 對象。

2. 對象以值傳遞的方式從函數返回

class CExample
{
private:
 int a;

public:
 //構造函數
 CExample(int b)
 {
  a = b;
 }

 //拷貝構造
 CExample(const CExample& C)
 {
  a = C.a;
  cout<<"copy"<<endl;
 }

     void Show ()
     {
         cout<<a<<endl;
     }
};

//全局函數
CExample g_Fun()
{
 CExample temp(0);
 return temp;
}

int main()
{
 g_Fun();
 return 0;
}

當g_Fun()函數執行到return時，會產生以下幾個重要步驟：
(1). 先會產生一個臨時變量，就叫XXXX吧。
(2). 然後調用拷貝構造函數把temp的值給XXXX。整個這兩個步驟有點像：CExample XXXX(temp);
(3). 在函數執行到最後先析構temp局部變量。
(4). 等g_Fun()執行完後再析構掉XXXX對象。

3. 對象需要通過另外一個對象進行初始化；

CExample A(100);
CExample B = A;
// CExample B(A);

後兩句都會調用拷貝構造函數。

三. 淺拷貝和深拷貝

1. 默認拷貝構造函數

    很多時候在我們都不知道拷貝構造函數的情況下，傳遞對象給函數參數或者函數返回對象都能很好的進行，這是因爲編譯器會給我們自動產生一個拷貝構造函數，這就是“默認拷貝構造函數”，這個構造函數很簡單，僅僅使用“老對象”的數據成員的值對“新對象”的數據成員一一進行賦值，它一般具有以下形式：

Rect::Rect(const Rect& r)
{
    width = r.width;
    height = r.height;
}

 
    當然，以上代碼不用我們編寫，編譯器會爲我們自動生成。但是如果認爲這樣就可以解決對象的複製問題，那就錯了，讓我們來考慮以下一段代碼：

class Rect
{
public:
    Rect()      // 構造函數，計數器加1
    {
        count++;
    }
    ~Rect()     // 析構函數，計數器減1
    {
        count--;
    }
    static int getCount()       // 返回計數器的值
    {
        return count;
    }
private:
    int width;
    int height;
    static int count;       // 一靜態成員做爲計數器
};

int Rect::count = 0;        // 初始化計數器

int main()
{
    Rect rect1;
    cout<<"The count of Rect: "<<Rect::getCount()<<endl;

    Rect rect2(rect1);   // 使用rect1複製rect2，此時應該有兩個對象
     cout<<"The count of Rect: "<<Rect::getCount()<<endl;

    return 0;
}

　　這段代碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函數中，首先創建對象rect1，輸出此時的對象個數，然後使用rect1複製出對象rect2，再輸出此時的對象個數，按照理解，此時應該有兩個對象存在，但實際程序運行時，輸出的都是1，反應出只有1個對象。此外，在銷燬對象時，由於會調用銷燬兩個對象，類的析構函數會調用兩次，此時的計數器將變爲負數。

說白了，就是拷貝構造函數沒有處理靜態數據成員。

出現這些問題最根本就在於在複製對象時，計數器沒有遞增，我們重新編寫拷貝構造函數，如下：

class Rect
{
public:
    Rect()      // 構造函數，計數器加1
    {
        count++;
    }
    Rect(const Rect& r)   // 拷貝構造函數
    {
        width = r.width;
        height = r.height;
        count++;          // 計數器加1
    }
    ~Rect()     // 析構函數，計數器減1
    {
        count--;
    }
    static int getCount()   // 返回計數器的值
    {
        return count;
    }
private:
    int width;
    int height;
    static int count;       // 一靜態成員做爲計數器
};

2. 淺拷貝

    所謂淺拷貝，指的是在對象複製時，只對對象中的數據成員進行簡單的賦值，默認拷貝構造函數執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦對象存在了動態成員，那麼淺拷貝就會出問題了，讓我們考慮如下一段代碼：

class Rect
{
public:
    Rect()      // 構造函數，p指向堆中分配的一空間
    {
        p = new int(100);
    }
    ~Rect()     // 析構函數，釋放動態分配的空間
    {
        if(p != NULL)
        {
            delete p;
        }
    }
private:
    int width;
    int height;
    int *p;     // 一指針成員
};

int main()
{
    Rect rect1;
    Rect rect2(rect1);   // 複製對象
    return 0;
}

    在這段代碼運行結束之前，會出現一個運行錯誤。原因就在於在進行對象複製時，對於動態分配的內容沒有進行正確的操作。我們來分析一下：

    在運行定義rect1對象後，由於在構造函數中有一個動態分配的語句，因此執行後的內存情況大致如下：

 

 

    在使用rect1複製rect2時，由於執行的是淺拷貝，只是將成員的值進行賦值，這時 rect1.p = rect2.p，也即這兩個指針指向了堆裏的同一個空間，如下圖所示：

 

當然，這不是我們所期望的結果，在銷燬對象時，兩個對象的析構函數將對同一個內存空間釋放兩次，這就是錯誤出現的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。

3. 深拷貝

    在“深拷貝”的情況下，對於對象中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：

class Rect
{
public:
    Rect()      // 構造函數，p指向堆中分配的一空間
    {
        p = new int(100);
    }
    Rect(const Rect& r)
    {
        width = r.width;
        height = r.height;
        p = new int;    // 爲新對象重新動態分配空間
        *p = *(r.p);
    }
    ~Rect()     // 析構函數，釋放動態分配的空間
    {
        if(p != NULL)
        {
            delete p;
        }
    }
private:
    int width;
    int height;
    int *p;     // 一指針成員
};

此時，在完成對象的複製後，內存的一個大致情況如下：

 

此時rect1的p和rect2的p各自指向一段內存空間，但它們指向的空間具有相同的內容，這就是所謂的“深拷貝”。

3. 防止默認拷貝發生

    通過對對象複製的分析，我們發現對象的複製大多在進行“值傳遞”時發生，這裏有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構造函數。甚至不必去定義這個拷貝構造函數，這樣因爲拷貝構造函數是私有的，如果用戶試圖按值傳遞或函數返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象。

// 防止按值傳遞
class CExample
{
private:
    int a;

public:
    //構造函數
    CExample(int b)
    {
        a = b;
        cout<<"creat: "<<a<<endl;
    }

private:
    //拷貝構造，只是聲明
    CExample(const CExample& C);

public:
    ~CExample()
    {
        cout<< "delete: "<<a<<endl;
    }

    void Show ()
    {
        cout<<a<<endl;
    }
};

//全局函數
void g_Fun(CExample C)
{
    cout<<"test"<<endl;
}

int main()
{
    CExample test(1);
    //g_Fun(test); 按值傳遞將出錯

    return 0;
}

四. 拷貝構造函數的幾個細節

1. 拷貝構造函數裏能調用private成員變量嗎?
解答：這個問題是在網上見的，當時一下子有點暈。其時從名子我們就知道拷貝構造函數其時就是一個特殊的構造函數，操作的還是自己類的成員變量，所以不受private的限制。

2. 以下函數哪個是拷貝構造函數,爲什麼?

X::X(const X&);
X::X(X);
X::X(X&, int a=1);
X::X(X&, int a=1, int b=2);

解答：對於一個類X, 如果一個構造函數的第一個參數是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且沒有其他參數或其他參數都有默認值,那麼這個函數是拷貝構造函數.

X::X(const X&);  //是拷貝構造函數
X::X(X&, int=1); //是拷貝構造函數
X::X(X&, int a=1, int b=2); //當然也是拷貝構造函數

3. 一個類中可以存在多於一個的拷貝構造函數嗎?
解答：類中可以存在超過一個拷貝構造函數。

class X {
public:
  X(const X&);      // const 的拷貝構造
  X(X&);            // 非const的拷貝構造
};

注意,如果一個類中只存在一個參數爲 X& 的拷貝構造函數,那麼就不能使用const X或volatile X的對象實行拷貝初始化.

class X {
public:
  X();
  X(X&);
};

const X cx;
X x = cx;    // error

如果一個類中沒有定義拷貝構造函數,那麼編譯器會自動產生一個默認的拷貝構造函數。
這個默認的參數可能爲 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪一個。