c++拷貝函數詳解(轉)
一. 什麽是拷貝構造函數
首先對於普通類型的對象來說，它們之間的復制是很簡單的，例如
- int a = 100;
- int b = a;
而類對象與普通對象不同，類對象內部結構一般較為復雜，存在各種成員變量。
下面看一個類對象拷貝的簡單例子。
1 #include <iostream> 2 using namespace std; 3 4 class CExample { 5 private: 6 int a; 7 public: 8 //構造函數 9 CExample(int b)10 { a = b;} 11 12 //一般函數 13 void Show () 14 { 15 cout<<a<<endl; 16 } 17 }; 18 19 int main() 20 { 21 CExample A(100); 22 CExample B = A; //註意這裏的對象初始化要調用拷貝構造函數，而非賦值 23 B.Show (); 24 return 0; 25 }
運行程序，屏幕輸出100。從以上代碼的運行結果可以看出，系統為對象 B 分配了內存並完成了與對象 A 的復制過程。就類對象而言，相同類型的類對象是通過拷貝構造函數來完成整個復制過程的。
下面舉例說明拷貝構造函數的工作過程。
1 #include <iostream> 2 using namespace std; 3 4 class CExample { 5 private: 6 int a; 7 public: 8 //構造函數 9 CExample(int b) 10 { a = b;} 11 12 //拷貝構造函數 13 CExample(const CExample& C) 14 { 15 a = C.a;16 } 17 18 //一般函數 19 void Show () 20 { 21 cout<<a<<endl; 22 } 23 }; 24 25 int main() 26 { 27 CExample A(100); 28 CExample B = A; // CExample B(A); 也是一樣的 29 B.Show (); 30 return 0; 31 }
CExample(const CExample& C) 就是我們自定義的拷貝構造函數。可見，拷貝構造函數是一種特殊的構造函數，函數的名稱必須和類名稱一致，它必須的一個參數是本類型的一個引用變量。
二. 拷貝構造函數的調用時機
在C++中，下面三種對象需要調用拷貝構造函數！
1. 對象以值傳遞的方式傳入函數參數
調用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; 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()函數執行到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. 默認拷貝構造函數
很多時候在我們都不知道拷貝構造函數的情況下，傳遞對象給函數參數或者函數返回對象都能很好的進行，這是因為編譯器會給我們自動產生一個拷貝構造函數，這就是“默認拷貝構造函數”，這個構造函數很簡單，僅僅使用“老對象”的數據成員的值對“新對象”的數據成員一一進行賦值，它一般具有以下形式：
1 Rect::Rect(const Rect& r) 2 { 3 width = r.width; 4 height = r.height; 5 }
當然，以上代碼不用我們編寫，編譯器會為我們自動生成。但是如果認為這樣就可以解決對象的復制問題，那就錯了，讓我們來考慮以下一段代碼：
1 class Rect 2 { 3 public: 4 Rect() // 構造函數，計數器加1 5 { 6 count++; 7 } 8 ~Rect() // 析構函數，計數器減1 9 { 10 count--; 11 } 12 static int getCount() // 返回計數器的值 13 { 14 return count; 15 } 16 private: 17 int width; 18 int height; 19 static int count; // 一靜態成員做為計數器 20 }; 21 22 int Rect::count = 0; // 初始化計數器 23 24 int main() 25 { 26 Rect rect1; 27 cout<<"The count of Rect: "<<Rect::getCount()<<endl; 28 29 Rect rect2(rect1); // 使用rect1復制rect2，此時應該有兩個對象 30 cout<<"The count of Rect: "<<Rect::getCount()<<endl; 31 32 return 0; 33 }
這段代碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函數中，首先創建對象rect1，輸出此時的對象個數，然後使用rect1復制出對象rect2，再輸出此時的對象個數，按照理解，此時應該有兩個對象存在，但實際程序運行時，輸出的都是1，反應出只有1個對象。此外，在銷毀對象時，由於會調用銷毀兩個對象，類的析構函數會調用兩次，此時的計數器將變為負數。
說白了，就是拷貝構造函數沒有處理靜態數據成員。
出現這些問題最根本就在於在復制對象時，計數器沒有遞增，我們重新編寫拷貝構造函數，如下：
1 class Rect 2 { 3 public: 4 Rect() // 構造函數，計數器加1 5 { 6 count++; 7 } 8 Rect(const Rect& r) // 拷貝構造函數 9 { 10 width = r.width; 11 height = r.height; 12 count++; // 計數器加1 13 } 14 ~Rect() // 析構函數，計數器減1 15 { 16 count--; 17 } 18 static int getCount() // 返回計數器的值 19 { 20 return count; 21 } 22 private: 23 int width; 24 int height; 25 static int count; // 一靜態成員做為計數器 26 };
2. 淺拷貝
所謂淺拷貝，指的是在對象復制時，只對對象中的數據成員進行簡單的賦值，默認拷貝構造函數執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦對象存在了動態成員，那麽淺拷貝就會出問題了，讓我們考慮如下一段代碼：
1 class Rect 2 { 3 public: 4 Rect() // 構造函數，p指向堆中分配的一空間 5 { 6 p = new int(100); 7 } 8 ~Rect() // 析構函數，釋放動態分配的空間 9 { 10 if(p != NULL) 11 { 12 delete p; 13 } 14 } 15 private: 16 int width; 17 int height; 18 int *p; // 一指針成員 19 }; 20 21 int main() 22 { 23 Rect rect1; 24 Rect rect2(rect1); // 復制對象 25 return 0; 26 }
在這段代碼運行結束之前，會出現一個運行錯誤。原因就在於在進行對象復制時，對於動態分配的內容沒有進行正確的操作。我們來分析一下：
在運行定義rect1對象後，由於在構造函數中有一個動態分配的語句，因此執行後的內存情況大致如下：
在使用rect1復制rect2時，由於執行的是淺拷貝，只是將成員的值進行賦值，這時 rect1.p= rect2.p，也即這兩個指針指向了堆裏的同一個空間，如下圖所示：
當然，這不是我們所期望的結果，在銷毀對象時，兩個對象的析構函數將對同一個內存空間釋放兩次，這就是錯誤出現的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。
3. 深拷貝
在“深拷貝”的情況下，對於對象中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：
1 class Rect 2 { 3 public: 4 Rect() // 構造函數，p指向堆中分配的一空間 5 { 6 p = new int(100); 7 } 8 Rect(const Rect& r) 9 { 10 width = r.width; 11 height = r.height; 12 p = new int; // 為新對象重新動態分配空間 13 *p = *(r.p); 14 } 15 ~Rect() // 析構函數，釋放動態分配的空間 16 { 17 if(p != NULL) 18 { 19 delete p; 20 } 21 } 22 private: 23 int width; 24 int height; 25 int *p; // 一指針成員 26 };
此時，在完成對象的復制後，內存的一個大致情況如下：
此時rect1的p和rect2的p各自指向一段內存空間，但它們指向的空間具有相同的內容，這就是所謂的“深拷貝”。
3. 防止默認拷貝發生
通過對對象復制的分析，我們發現對象的復制大多在進行“值傳遞”時發生，這裏有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構造函數。甚至不必去定義這個拷貝構造函數，這樣因為拷貝構造函數是私有的，如果用戶試圖按值傳遞或函數返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象
1 // 防止按值傳遞 2 class CExample 3 { 4 private: 5 int a; 6 7 public: 8 //構造函數 9 CExample(int b) 10 { 11 a = b; 12 cout<<"creat: "<<a<<endl; 13 } 14 15 private: 16 //拷貝構造，只是聲明 17 CExample(const CExample& C); 18 19 public: 20 ~CExample() 21 { 22 cout<< "delete: "<<a<<endl; 23 } 24 25 void Show () 26 { 27 cout<<a<<endl; 28 } 29 }; 30 31 //全局函數 32 void g_Fun(CExample C) 33 { 34 cout<<"test"<<endl; 35 } 36 37 int main() 38 { 39 CExample test(1); 40 //g_Fun(test); 按值傳遞將出錯 41 42 return 0; 43 }
四. 拷貝構造函數的幾個細節
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&),由編譯器根據上下文決定選擇哪一個。
c++拷貝函數詳解(轉)