碼上快樂

相關內容    簡體    繁體

對深拷貝與淺拷貝的再次理解（默認構造函數是淺拷貝）

本文轉載自   查看原文   2016-08-24 22:21   1898    C++ 構造與析構

   記得11年底找工作的時候，面試時曾經遇到有面試官問的對深拷貝與淺拷貝的理解，那時候自己回來查了資料，寫了篇博客（點擊打開鏈接），感覺自己理解了，其實理解的不深刻，最近在調試bug的時候，再次遇到深拷貝與淺拷貝，認真分析了，寫寫自己的心得吧。

    先說下自己的理解吧，淺拷貝，即在定義一個類A，使用類似A obj;  A obj1(obj);或者A obj1 = obj; 時候，由於沒有自定義拷貝構造函數，C++編譯器自動會產生一個默認的拷貝構造函數。這個默認的拷貝構造函數采用的是“位拷貝”（淺拷貝），而非“值拷貝”（深拷貝）的方式，如果類中含有指針變量，默認的拷貝構造函數必定出錯。

用一句簡單的話來說就是淺拷貝，只是對指針的拷貝，拷貝后兩個指針指向同一個內存空間，深拷貝不但對指針進行拷貝，而且對指針指向的內容進行拷貝，經深拷貝后的指針是指向兩個不同地址的指針。

 

    淺拷貝會出現什么問題呢？

假如有一個成員變量的指針，char *m_data;

其一，淺拷貝只是拷貝了指針，使得兩個指針指向同一個地址，這樣在對象塊結束，調用函數析構的時，會造成同一份資源析構2次，即delete同一塊內存2次，造成程序崩潰。

其二，淺拷貝使得obj.m_data和obj1.m_data指向同一塊內存，任何一方的變動都會影響到另一方。

其三，在釋放內存的時候，會造成obj1.m_data原有的內存沒有被釋放（這句話，剛開始我不太理解，如果沒有走自定義的拷貝構造函數申請內存空間，A obj1(obj);也不走默認構造函數，走的是默認的拷貝構造函數，何來分配空間這一說，更不會造成obj1.m_data原有的內存沒有被釋放，這里剛開始我一直有疑問），造成內存泄露。

事實是這樣的，當delete obj.m_data, obj.m_data內存被釋放后，由於之前obj.m_data和obj1.m_data指向的是同一個內存空間，obj1.m_data所指的空間不能在被利用了，delete obj1.m_data也不會成功，一致已經無法操作該空間，所以導致內存泄露。

 

    深拷貝采用了在堆內存中申請新的空間來存儲數據，這樣每個可以避免指針懸掛。

 

    下面來看看類string的拷貝構造函數

[cpp]  view plain  copy
 
  1. 　　class String  
  2. 　　{  
  3. 　　    public:  
  4. 　　        String(const String &other);    //拷貝構造函數  
  5. 　　    private:  
  6. 　　        char *m_data;   //用於保存字符串  
  7. 　　};    
  8. 　　  
  9. 　　String(const String &other)  
  10. 　　{     
  11. 　　    int length = strlen(other.m_data);  
  12. 　　    m_data = new char[length + 1];  
  13. 　　    strcpy(m_data, other.m_data);  
  14. }   


 

    可以看到在拷貝構造函數中為成員變量申請了新的內存空間，這就使得兩個對象的成員變量不指向同一個內存空間，除非你的確需要這樣做，用於實現一些其他的用途。

 

    淺拷貝：也就是在對象復制時，只是對對象中的數據成員進行簡單的賦值，如果對象中存在動態成員，即指針，淺拷貝就會出現問題，下面代碼：

[cpp]  view plain  copy
 
  1. #include <stdio.h>  
  2.   
  3. class A  
  4. {  
  5.     public:  
  6.         A()      // 構造函數，p指向堆中分配的一空間  
  7.         {  
  8.             m_data = new char(100);  
  9.             printf("默認構造函數\n");  
  10.         }  
  11.         ~A()     // 析構函數，釋放動態分配的空間  
  12.         {  
  13.             if(m_data != NULL)  
  14.             {  
  15.                 delete m_data;  
  16.                 m_data = NULL;  
  17.                 printf("析構函數\n");  
  18.             }  
  19.         }  
  20.     private:  
  21.         char *m_data;     // 一指針成員  
  22. };  
  23.   
  24. int main()  
  25. {  
  26.     A a;  
  27.     A b(a);   // 復制對象  
  28.     return 0;  
  29. }  

運行結果：

*** glibc detected *** ./simple: double free or corruption (fasttop): 0x000000000c62a010 ***

分析：由於沒有拷貝構造函數，走編譯器默認的拷貝構造函數，A b(a); 進行對象析構時，會造成釋放同一內存空間2次，導致內存泄露。

 

    深拷貝：對於深拷貝，針對成員變量存在指針的情況，不僅僅是簡單的指針賦值，而是重新分配內存空間，如下：

[cpp]  view plain  copy
 
  1. #include <stdio.h>  
  2. #include <string>  
  3.   
  4. class A  
  5. {  
  6.     public:  
  7.         A()      // 構造函數，p指向堆中分配的一空間  
  8.         {  
  9.             m_pdata = new char(100);  
  10.             printf("默認構造函數\n");  
  11.         }  
  12.   
  13.         A(const A& r)  
  14.         {  
  15.             m_pdata = new char(100);    // 為新對象重新動態分配空間  
  16.             memcpy(m_pdata, r.m_pdata, strlen(r.m_pdata));  
  17.             printf("copy構造函數\n");  
  18.         }  
  19.   
  20.         ~A()     // 析構函數，釋放動態分配的空間  
  21.         {  
  22.             if(m_pdata != NULL)  
  23.             {  
  24.                 delete m_pdata;  
  25.                 printf("析構函數\n");  
  26.             }  
  27.         }  
  28.   
  29.     private:  
  30.         char *m_pdata;     // 一指針成員  
  31. };  
  32.   
  33. int main()  
  34. {  
  35.     A a;  
  36.     A b(a);   // 復制對象  
  37.     return 0;  
  38. }  


 

    下面是我在具體的應用中使用深拷貝的情況，現在把這個demo貼出來：

[cpp]  view plain  copy
 
  1. #include <iostream>  
  2. #include <errno.h>  
  3. #include <vector>  
  4. #include <stdio.h>  
  5.   
  6. using namespace std;  
  7.   
  8. /*存儲記錄信息的結構體*/  
  9. typedef struct _RECODER_VALUE_STRU  
  10. {  
  11.         int Id;  
  12.         int Age;  
  13. }RECODER_VALUE_STRU;  
  14.   
  15. class recorder  
  16. {  
  17.         public:  
  18.                 recorder()  
  19.                 {  
  20.                         m_stru_RecValue.Id = -1;  
  21.                         m_stru_RecValue.Age = -1;  
  22.                         m_pRecValue = &m_stru_RecValue;  
  23.   
  24.                         m_paddr = new char[100];  
  25.                         memset(m_paddr,0x00 ,100);  
  26.   
  27.                         printf("默認 construct recorder->&m_stru_RecValue: %x,\t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecVa  
  28. lue, m_paddr);  
  29.                 }  
  30.   
  31.                 //拷貝構造函數  
  32. /*              recorder(const recorder &recorder) 
  33.                 { 
  34.                         m_stru_RecValue.Id = -1;        
  35.                         m_stru_RecValue.Age = -1; 
  36.                         m_stru_RecValue = recorder.m_stru_RecValue; 
  37.                         m_pRecValue = &m_stru_RecValue; 
  38.  
  39.                         m_paddr = new char[100]; 
  40.                         memset(m_paddr, 0x00 ,100); 
  41.                         memcpy(m_paddr, recorder.m_paddr, strlen(recorder.m_paddr)); 
  42.  
  43.                         printf("拷貝 construct recorder->&m_stru_RecValue: %x\t m_pRecValue: %x\t m_paddr: %x\n",&m_stru_RecValue, m_pRecValu 
  44. e, m_paddr); 
  45.                 } 
  46. */  
  47.                 //構造函數  
  48.                 recorder(int iId, int iAge)  
  49.                 {  
  50.                         m_stru_RecValue.Id = iId;  
  51.                         m_stru_RecValue.Age = iAge;  
  52.                         m_pRecValue = &m_stru_RecValue;  
  53.   
  54.                         m_paddr = new char[100];  
  55.                         memset(m_paddr, 0x00 ,100);  
  56.                         memcpy(m_paddr, &iAge, sizeof(int));  
  57.   
  58.                         printf("construct recorder->&m_stru_RecValue: %x \t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecValue,  
  59. m_paddr);  
  60.                 }  
  61.   
  62.                 ~recorder()  
  63.                 {  
  64.                 //      cout<<"recorder 析構"<<endl;  
  65.                         /*if(m_paddr != NULL) 
  66.                         { 
  67.                                 delete m_paddr; 
  68.                                 m_paddr =NULL; 
  69.                         }*/  
  70.                 }  
  71.   
  72.         public:  
  73.                 RECODER_VALUE_STRU m_stru_RecValue;//存儲記錄信息的結構體   
  74.                 void* m_pRecValue;//每條記錄的值  
  75.                 char *m_paddr;  
  76. };  
  77.   
  78. int main()  
  79. {  
  80.         cout <<"測試默認構造函數"<<endl<<endl;  
  81.         recorder btest;  
  82.         recorder btest1(btest);  
  83.   
  84.         printf("非參：btest ->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n",  &btest.m_stru_RecValue, btest.m_pRecValue,  btest.m_paddr);  
  85.         printf("非參：btest1->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n", &btest1.m_stru_RecValue, btest1.m_pRecValue, btest1.m_paddr);  
  86.   
  87.   
  88.         cout << endl<<"測試帶參數的構造函數"<<endl<<endl;  
  89.   
  90.   
  91.         recorder btest2(1, 100);  
  92.         recorder btest3(btest2);  
  93.         printf("帶參：btest2->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest2.m_stru_RecValue, btest2.m_pRecValue, btest2.m_  
  94. paddr);  
  95.         printf("帶參：btest3->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest3.m_stru_RecValue, btest3.m_pRecValue, btest3.m_  
  96. paddr);  
  97.   
  98.   
  99.         return 0;  
  100. }  

對比結果：

注釋掉自定義拷貝構造函數,運行結果：

測試默認構造函數

 

默認 construct recorder->&m_stru_RecValue: ddbb8de0,     m_pRecValue: ddbb8de0   m_paddr: 1b8a0010

非參：btest ->&m_stru_RecValue: ddbb8de0         addr: ddbb8de0  m_paddr: 1b8a0010

非參：btest1->&m_stru_RecValue: ddbb8dc0         addr: ddbb8de0  m_paddr: 1b8a0010

 

測試帶參數的構造函數

 

construct recorder->&m_stru_RecValue: ddbb8da0   m_pRecValue: ddbb8da0   m_paddr: 1b8a0080

帶參：btest2->m_stru_RecValue: ddbb8da0  m_pRecValue: ddbb8da0  , m_paddr: 1b8a0080

帶參：btest3->m_stru_RecValue: ddbb8d80  m_pRecValue: ddbb8da0  , m_paddr: 1b8a0080

默認拷貝構造函數結果分析：

通過結果可以看出，當成員變量為指針變量的時候，指針成員變量指向的地址都是同一個地址，無論是申請空間的成員變量m_pRecValue，和僅僅作為指針賦值的成員變量m_paddr；結構體的地址是變化的，除指針外其他成員淺拷貝與深拷貝沒什么區別。

 

 

 

打開自定義拷貝構造函數，運行結果：

測試默認構造函數

 

默認 construct recorder->&m_stru_RecValue: 58bb9e20,     m_pRecValue: 58bb9e20   m_paddr: 7a2c010

拷貝 construct recorder->&m_stru_RecValue: 58bb9e00      m_pRecValue: 58bb9e00   m_paddr: 7a2c080

非參：btest ->&m_stru_RecValue: 58bb9e20         addr: 58bb9e20  m_paddr: 7a2c010

非參：btest1->&m_stru_RecValue: 58bb9e00         addr: 58bb9e00  m_paddr: 7a2c080

 

測試帶參數的構造函數

 

construct recorder->&m_stru_RecValue: 58bb9de0   m_pRecValue: 58bb9de0   m_paddr: 7a2c0f0

拷貝 construct recorder->&m_stru_RecValue: 58bb9dc0      m_pRecValue: 58bb9dc0   m_paddr: 7a2c160

帶參：btest2->m_stru_RecValue: 58bb9de0  m_pRecValue: 58bb9de0  , m_paddr: 7a2c0f0

帶參：btest3->m_stru_RecValue: 58bb9dc0  m_pRecValue: 58bb9dc0  , m_paddr: 7a2c160

 

 

自定義深拷貝構造函數結果分析：

從結果可以看出，所有成員變量的地址都不相同。

 

其他：

1. 有時候為了防止默認拷貝發生，可以聲明一個私有的拷貝構造函數（不用寫代碼），這樣的話，如果試圖調用 A  b(a); 就調用了私有的拷貝構造函數，編譯器會報錯，這也是一種偷懶的做法。

2.  一個類中可以存在多個拷貝構造函數，例如：

[cpp]  view plain  copy
 
  1. Calss A  
  2. {  
  3. Public:  
  4. X(const X&);//const拷貝構造  
  5. X(X &);//非const拷貝構造  
  6. X(X& , int  iData);  
  7. }  

暫時就先分析到這里，如果以后遇到新的關於拷貝構造的情況，會繼續分析。

如是轉載，請指明原出處：http://blog.csdn.net/feitianxuxue，謝謝合作！


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 C++拷貝構造函數：淺拷貝與深拷貝 C++ 默認拷貝構造函數 深度拷貝和淺拷貝 【函數】深拷貝和淺拷貝 深拷貝淺拷貝 淺拷貝、深拷貝 java拷貝構造函數 拷貝構造函數的重載 為什么需要拷貝構造函數 幾個例子理解淺拷貝和深拷貝 java引用類型的淺拷貝與深拷貝理解
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM