C++拷貝建構函式詳解

TuxedoLinux發表於2018-06-11
C++函式

C++拷貝建構函式詳解


一. 什麼是拷貝建構函式

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

[c-sharp] view plain copy
  1. int a = 100;  
  2. int b = a;   

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

[c-sharp] view plain copy
  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 的複製過程。就類物件而言，相同型別的類物件是通過拷貝建構函式來完成整個複製過程的。

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

[c-sharp] view plain copy
  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. 物件以值傳遞的方式傳入函式引數

[c-sharp] view plain copy
  1. class CExample   
  2. {  
  3. private:  
  4.  int a;  
  5.   
  6. public:  
  7.  //建構函式  
  8.  CExample(int b)  
  9.  {   
  10.   a = b;  
  11.   cout<<"creat: "<<a<<endl;  
  12.  }  
  13.   
  14.  //拷貝構造  
  15.  CExample(const CExample& C)  
  16.  {  
  17.   a = C.a;  
  18.   cout<<"copy"<<endl;  
  19.  }  
  20.    
  21.  //解構函式  
  22.  ~CExample()  
  23.  {  
  24.   cout<< "delete: "<<a<<endl;  
  25.  }  
  26.   
  27.      void Show ()  
  28.  {  
  29.          cout<<a<<endl;  
  30.      }  
  31. };  
  32.   
  33. //全域性函式，傳入的是物件  
  34. void g_Fun(CExample C)  
  35. {  
  36.  cout<<"test"<<endl;  
  37. }  
  38.   
  39. int main()  
  40. {  
  41.  CExample test(1);  
  42.  //傳入物件  
  43.  g_Fun(test);  
  44.   
  45.  return 0;  
  46. }  

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

2. 物件以值傳遞的方式從函式返回

[c-sharp] view plain copy
  1. class CExample   
  2. {  
  3. private:  
  4.  int a;  
  5.   
  6. public:  
  7.  //建構函式  
  8.  CExample(int b)  
  9.  {   
  10.   a = b;  
  11.  }  
  12.   
  13.  //拷貝構造  
  14.  CExample(const CExample& C)  
  15.  {  
  16.   a = C.a;  
  17.   cout<<"copy"<<endl;  
  18.  }  
  19.   
  20.      void Show ()  
  21.      {  
  22.          cout<<a<<endl;  
  23.      }  
  24. };  
  25.   
  26. //全域性函式  
  27. CExample g_Fun()  
  28. {  
  29.  CExample temp(0);  
  30.  return temp;  
  31. }  
  32.   
  33. int main()  
  34. {  
  35.  g_Fun();  
  36.  return 0;  
  37. }  

當g_Fun()函式執行到return時，會產生以下幾個重要步驟：
(1). 先會產生一個臨時變數，就叫XXXX吧。
(2). 然後呼叫拷貝建構函式把temp的值給XXXX。整個這兩個步驟有點像：CExample XXXX(temp);
(3). 在函式執行到最後先析構temp區域性變數。
(4). 等g_Fun()執行完後再析構掉XXXX物件。

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

[c-sharp] view plain copy
  1. CExample A(100);  
  2. CExample B = A;   
  3. // CExample B(A);   

後兩句都會呼叫拷貝建構函式。


三. 淺拷貝和深拷貝

1. 預設拷貝建構函式

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

[c-sharp] view plain copy
  1. Rect::Rect(const Rect& r)  
  2. {  
  3.     width = r.width;  
  4.     height = r.height;  
  5. }  
 
    當然，以上程式碼不用我們編寫，編譯器會為我們自動生成。但是如果認為這樣就可以解決物件的複製問題，那就錯了，讓我們來考慮以下一段程式碼：
[c-sharp] view plain copy
  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個物件。此外，在銷燬物件時，由於會呼叫銷燬兩個物件，類的解構函式會呼叫兩次，此時的計數器將變為負數。

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

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

[c-sharp] view plain copy
  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. 淺拷貝

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

[c-sharp] view plain copy
  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. 深拷貝

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

[c-sharp] view plain copy
  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. 防止預設拷貝發生

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

[c-sharp] view plain copy
  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. 以下函式哪個是拷貝建構函式,為什麼?

[c-sharp] view plain copy
  1. X::X(const X&);      
  2. X::X(X);      
  3. X::X(X&, int a=1);      
  4. X::X(X&, int a=1, int b=2);  

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

[c-sharp] view plain copy
  1. X::X(const X&);  //是拷貝建構函式      
  2. X::X(X&, int=1); //是拷貝建構函式     
  3. X::X(X&, int a=1, int b=2); //當然也是拷貝建構函式  


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

[c-sharp] view plain copy
  1. class X {   
  2. public:         
  3.   X(const X&);      // const 的拷貝構造  
  4.   X(X&);            // 非const的拷貝構造  
  5. };  

注意,如果一個類中只存在一個引數為 X& 的拷貝建構函式,那麼就不能使用const X或volatile X的物件實行拷貝初始化.

[c-sharp] view plain copy
  1. class X {      
  2. public:  
  3.   X();      
  4.   X(X&);  
  5. };      
  6.   
  7. const X cx;      
  8. X x = cx;    // error  

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

相關文章