一. 什麼是拷貝建構函式
首先對於普通型別的物件來說，它們之間的複製是很簡單的，例如：
|
1 2 |
int a = 100; int b = a; |
而類物件與普通物件不同，類物件內部結構一般較為複雜，存在各種成員變數。
下面看一個類物件拷貝的簡單例子。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#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 的複製過程。就類物件而言，相同型別的類物件是通過拷貝建構函式來完成整個複製過程的。
下面舉例說明拷貝建構函式的工作過程。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#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. 物件以值傳遞的方式傳入函式引數
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
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. 物件以值傳遞的方式從函式返回
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
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. 物件需要通過另外一個物件進行初始化；
|
1 2 3 |
CExample A(100); CExample B = A; // CExample B(A); |
後兩句都會呼叫拷貝建構函式。
三. 淺拷貝和深拷貝
1. 預設拷貝建構函式
很多時候在我們都不知道拷貝建構函式的情況下，傳遞物件給函式引數或者函式返回物件都能很好的進行，這是因為編譯器會給我們自動產生一個拷貝建構函式，這就是“預設拷貝建構函式”，這個建構函式很簡單，僅僅使用“老物件”的資料成員的值對“新物件”的資料成員一一進行賦值，它一般具有以下形式：
|
1 2 3 4 5 |
Rect::Rect(const Rect& r) { width = r.width; height = r.height; } |
當然，以上程式碼不用我們編寫，編譯器會為我們自動生成。但是如果認為這樣就可以解決物件的複製問題，那就錯了，讓我們來考慮以下一段程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
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個物件。此外，在銷燬物件時，由於會呼叫銷燬兩個物件，類的解構函式會呼叫兩次，此時的計數器將變為負數。
說白了，就是拷貝建構函式沒有處理靜態資料成員。
出現這些問題最根本就在於在複製物件時，計數器沒有遞增，我們重新編寫拷貝建構函式，如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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. 淺拷貝
所謂淺拷貝，指的是在物件複製時，只對物件中的資料成員進行簡單的賦值，預設拷貝建構函式執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦物件存在了動態成員，那麼淺拷貝就會出問題了，讓我們考慮如下一段程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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. 深拷貝
在“深拷貝”的情況下，對於物件中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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. 防止預設拷貝發生
通過對物件複製的分析，我們發現物件的複製大多在進行“值傳遞”時發生，這裡有一個小技巧可以防止按值傳遞——宣告一個私有拷貝建構函式。甚至不必去定義這個拷貝建構函式，這樣因為拷貝建構函式是私有的，如果使用者試圖按值傳遞或函式返回該類物件，將得到一個編譯錯誤，從而可以避免按值傳遞或返回物件。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
// 防止按值傳遞 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. 以下函式哪個是拷貝建構函式,為什麼?
|
1 2 3 4 |
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&
且沒有其他引數或其他引數都有預設值,那麼這個函式是拷貝建構函式.
|
1 2 3 |
X::X(const X&); //是拷貝建構函式 X::X(X&, int=1); //是拷貝建構函式 X::X(X&, int a=1, int b=2); //當然也是拷貝建構函式 |
3. 一個類中可以存在多於一個的拷貝建構函式嗎?
解答：類中可以存在超過一個拷貝建構函式。
|
1 2 3 4 5 |
class X { public: X(const X&); // const 的拷貝構造 X(X&); // 非const的拷貝構造 }; |
注意,如果一個類中只存在一個引數為 X& 的拷貝建構函式,那麼就不能使用const X或volatile X的物件實行拷貝初始化.
|
1 2 3 4 5 6 7 8 |
class X { public: X(); X(X&); }; const X cx; X x = cx; // error |
如果一個類中沒有定義拷貝建構函式,那麼編譯器會自動產生一個預設的拷貝建構函式。這個預設的引數可能為 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪一個。