C++拷貝建構函式詳解

一. 什麼是拷貝建構函式

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

int a = 100;<br />int b = a;
而類對象與普通對象不同，類對象內部結構一般較為複雜，存在各種成員變數。
下面看一個類對象拷貝的簡單例子。

#include <iostream><br />using namespace std;</p><p>class CExample {<br />private:<br /> 　int a;<br />public:<br /> //建構函式<br /> 　CExample(int b)<br /> 　{ a = b;}</p><p> //一般函數<br /> 　void Show ()<br /> 　{<br /> cout<<a<<endl;<br /> }<br />};</p><p>int main()<br />{<br /> 　CExample A(100);<br /> 　CExample B = A; //注意這裡的對象初始化要調用拷貝建構函式，而非賦值<br /> 　 B.Show ();<br /> 　return 0;<br />}

運行程式，螢幕輸出100。從以上代碼的運行結果可以看出，系統為對象 B 分配了記憶體並完成了與對象 A 的複製過程。就類對象而言，相同類型的類對象是通過拷貝建構函式來完成整個複製過程的。

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

#include <iostream><br />using namespace std;</p><p>class CExample {<br />private:<br /> int a;<br />public:<br /> //建構函式<br /> CExample(int b)<br /> { a = b;}</p><p> //拷貝建構函式<br /> CExample(const CExample& C)<br /> {<br /> a = C.a;<br /> }</p><p> //一般函數<br /> void Show ()<br /> {<br /> cout<<a<<endl;<br /> }<br />};</p><p>int main()<br />{<br /> CExample A(100);<br /> CExample B = A; // CExample B(A); 也是一樣的<br /> B.Show ();<br /> return 0;<br />}
CExample(const CExample& C)　就是我們自訂的拷貝建構函式。可見，拷貝建構函式是一種特殊的建構函式，函數的名稱必須和類名稱一致，它必須的一個參數是本類型的一個引用變數。

二. 拷貝建構函式的調用時機

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

class CExample<br />{<br />private:<br /> int a;</p><p>public:<br /> //建構函式<br /> CExample(int b)<br /> {<br /> a = b;<br /> cout<<"creat: "<<a<<endl;<br /> }</p><p> //拷貝構造<br /> CExample(const CExample& C)<br /> {<br /> a = C.a;<br /> cout<<"copy"<<endl;<br /> }</p><p> //解構函式<br /> ~CExample()<br /> {<br /> cout<< "delete: "<<a<<endl;<br /> }</p><p> void Show ()<br /> {<br /> cout<<a<<endl;<br /> }<br />};</p><p>//全域函數，傳入的是對象<br />void g_Fun(CExample C)<br />{<br /> cout<<"test"<<endl;<br />}</p><p>int main()<br />{<br /> CExample test(1);<br /> //傳入對象<br /> g_Fun(test);</p><p> return 0;<br />}
調用g_Fun()時，會產生以下幾個重要步驟：
(1).test對象傳入形參時，會先會產生一個臨時變數，就叫 C 吧。
(2).然後調用拷貝建構函式把test的值給C。 整個這兩個步驟有點像：CExample C(test);
(3).等g_Fun()執行完後, 析構掉 C 對象。

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

class CExample<br />{<br />private:<br /> int a;</p><p>public:<br /> //建構函式<br /> CExample(int b)<br /> {<br /> a = b;<br /> }</p><p> //拷貝構造<br /> CExample(const CExample& C)<br /> {<br /> a = C.a;<br /> cout<<"copy"<<endl;<br /> }</p><p> void Show ()<br /> {<br /> cout<<a<<endl;<br /> }<br />};</p><p>//全域函數<br />CExample g_Fun()<br />{<br /> CExample temp(0);<br /> return temp;<br />}</p><p>int main()<br />{<br /> g_Fun();<br /> return 0;<br />}
當g_Fun()函數執行到return時，會產生以下幾個重要步驟：
(1). 先會產生一個臨時變數，就叫XXXX吧。
(2). 然後調用拷貝建構函式把temp的值給XXXX。整個這兩個步驟有點像：CExample XXXX(temp);
(3). 在函數執行到最後先析構temp局部變數。
(4). 等g_Fun()執行完後再析構掉XXXX對象。

3. 對象需要通過另外一個對象進行初始化；
CExample A(100);<br />CExample B = A;<br />// CExample B(A);

後兩句都會調用拷貝建構函式。

三. 淺拷貝和深拷貝

1. 預設拷貝建構函式

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

Rect::Rect(const Rect& r)<br />{<br /> width = r.width;<br /> height = r.height;<br />} 
    當然，以上代碼不用我們編寫，編譯器會為我們自動產生。但是如果認為這樣就可以解決對象的複製問題，那就錯了，讓我們來考慮以下一段代碼：
class Rect<br />{<br />public:<br /> Rect() // 建構函式，計數器加1<br /> {<br /> count++;<br /> }<br /> ~Rect() // 解構函式，計數器減1<br /> {<br /> count--;<br /> }<br /> static int getCount() // 返回計數器的值<br /> {<br /> return count;<br /> }<br />private:<br /> int width;<br /> int height;<br /> static int count; // 一靜態成員做為計數器<br />};</p><p>int Rect::count = 0; // 初始化計數器</p><p>int main()<br />{<br /> Rect rect1;<br /> cout<<"The count of Rect: "<<Rect::getCount()<<endl;</p><p> Rect rect2(rect1); // 使用rect1複製rect2，此時應該有兩個對象<br /> cout<<"The count of Rect: "<<Rect::getCount()<<endl;</p><p> return 0;<br />}

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

說白了，就是拷貝建構函式沒有處理待用資料成員。

出現這些問題最根本就在於在複製對象時，計數器沒有遞增，我們重新編寫拷貝建構函式，如下：
class Rect<br />{<br />public:<br /> Rect() // 建構函式，計數器加1<br /> {<br /> count++;<br /> }<br /> Rect(const Rect& r) // 拷貝建構函式<br /> {<br /> width = r.width;<br /> height = r.height;<br /> count++; // 計數器加1<br /> }<br /> ~Rect() // 解構函式，計數器減1<br /> {<br /> count--;<br /> }<br /> static int getCount() // 返回計數器的值<br /> {<br /> return count;<br /> }<br />private:<br /> int width;<br /> int height;<br /> static int count; // 一靜態成員做為計數器<br />};

2. 淺拷貝

    所謂淺拷貝，指的是在對象複製時，只對對象中的資料成員進行簡單的賦值，預設拷貝建構函式執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦對象存在了動態成員，那麼淺拷貝就會出問題了，讓我們考慮如下一段代碼：
class Rect<br />{<br />public:<br /> Rect() // 建構函式，p指向堆中分配的一空間<br /> {<br /> p = new int(100);<br /> }<br /> ~Rect() // 解構函式，釋放動態分配的空間<br /> {<br /> if(p != NULL)<br /> {<br /> delete p;<br /> }<br /> }<br />private:<br /> int width;<br /> int height;<br /> int *p; // 一指標成員<br />};</p><p>int main()<br />{<br /> Rect rect1;<br /> Rect rect2(rect1); // 複製對象<br /> return 0;<br />}

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

    在運行定義rect1對象後，由於在建構函式中有一個動態分配的語句，因此執行後的記憶體情況大致如下：

 

 

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

 

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

3. 深拷貝

    在“深拷貝”的情況下，對於對象中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：
class Rect<br />{<br />public:<br /> Rect() // 建構函式，p指向堆中分配的一空間<br /> {<br /> p = new int(100);<br /> }<br /> Rect(const Rect& r)<br /> {<br /> width = r.width;<br /> height = r.height;<br /> p = new int; // 為新對象重新動態分配空間<br /> *p = *(r.p);<br /> }<br /> ~Rect() // 解構函式，釋放動態分配的空間<br /> {<br /> if(p != NULL)<br /> {<br /> delete p;<br /> }<br /> }<br />private:<br /> int width;<br /> int height;<br /> int *p; // 一指標成員<br />};

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

 

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

3. 防止預設拷貝發生

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

// 防止按值傳遞<br />class CExample<br />{<br />private:<br />int a;</p><p>public:<br />//建構函式<br />CExample(int b)<br />{<br />a = b;<br />cout<<"creat: "<<a<<endl;<br />}</p><p>private:<br />//拷貝構造，只是聲明<br />CExample(const CExample& C);</p><p>public:<br />~CExample()<br />{<br />cout<< "delete: "<<a<<endl;<br />}</p><p> void Show ()<br />{<br /> cout<<a<<endl;<br /> }<br />};</p><p>//全域函數<br />void g_Fun(CExample C)<br />{<br />cout<<"test"<<endl;<br />}</p><p>int main()<br />{<br />CExample test(1);<br />//g_Fun(test); 按值傳遞將出錯</p><p>return 0;<br />}

四. 拷貝建構函式的幾個細節

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

2. 以下函數哪個是拷貝建構函式,為什麼?

X::X(const X&);<br />X::X(X);<br />X::X(X&, int a=1);<br />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&); //是拷貝建構函式<br />X::X(X&, int=1); //是拷貝建構函式<br />X::X(X&, int a=1, int b=2); //當然也是拷貝建構函式

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

class X {<br />public:<br /> X(const X&); // const 的拷貝構造<br /> X(X&); // 非const的拷貝構造<br />};<br />
注意,如果一個類中只存在一個參數為 X& 的拷貝建構函式,那麼就不能使用const X或volatile X的對象實行拷貝初始化.

class X {<br />public:<br /> X();<br /> X(X&);<br />}; </p><p>const X cx;<br />X x = cx; // error<br />
如果一個類中沒有定義拷貝建構函式,那麼編譯器會自動產生一個預設的拷貝建構函式。
這個預設的參數可能為 X::X(const X&)或
X::X(X&),由編譯器根據上下文決定選擇哪一個。