python/c++ 深拷貝與淺拷貝（轉）

時間  2019-11-12
標籤 python c++ 拷貝 欄目 Python 简体版
原文   原文鏈接
1. copy.copy 淺拷貝 只拷貝父對象，不會拷貝對象的內部的子對象。
2. copy.deepcopy 深拷貝 拷貝對象及其子對象
一個很好的例子：
import copy
a = [ 1 , 2 , 3 , 4 , [ ' a ' , ' b ' ]] # 原始對象

b = a # 賦值，傳對象的引用
c = copy.copy(a) # 對象拷貝，淺拷貝
d = copy.deepcopy(a) # 對象拷貝，深拷貝

a.append( 5 ) # 修改對象a
a[ 4 ].append( ' c ' ) # 修改對象a中的['a', 'b']數組對象

print ' a = ' , a
 print ' b = ' , b
 print ' c = ' , c
 print ' d = ' , d

輸出結果：
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]

對於淺拷貝來講對象自己是新的，內容是舊的。 python

python的這一特色讓我想到了C++的拷貝構造函數與，好久沒有注意這塊內容，因而反箱倒海找了個網上比較不錯的資料以供比較： ios

如下是C++內容 數組

一. 什麼是拷貝構造函數
 app

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

int a = 100;
int b = a; 

 spa

而類對象與普通對象不一樣，類對象內部結構通常較爲複雜，存在各類成員變量。
下面看一個類對象拷貝的簡單例子。
  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 的複製過程。就類對象而言，相同類型的類對象是經過拷貝構造函數來完成整個複製過程的。 .net

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

[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. 對象以值傳遞的方式傳入函數參數 blog

  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 plaincopy
  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. 對象須要經過另一個對象進行初始化；

  1. CExample A(100);  
  2. CExample B = A;   
  3. // 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. 如下函數哪一個是拷貝構造函數,爲何?

  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&
且沒有其餘參數或其餘參數都有默認值,那麼這個函數是拷貝構造函數.
  1. X::X(const X&);  //是拷貝構造函數      
  2. X::X(X&, int=1); //是拷貝構造函數     
  3. X::X(X&, int a=1, int b=2); //固然也是拷貝構造函數  


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

  1. class X {   
  2. public:         
  3.   X(const X&);      // const 的拷貝構造  
  4.   X(X&);            // 非const的拷貝構造  
  5. };  

注意,若是一個類中只存在一個參數爲 X& 的拷貝構造函數,那麼就不能使用const X或volatile X的對象實行拷貝初始化.
  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&),由編譯器根據上下文決定選擇哪個。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程