zoukankan      html  css  js  c++  java

  • 对深拷贝与浅拷贝的再次理解（默认构造函数是浅拷贝）

       记得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("默认构造函数 ");  
    10.         }  
    11.         ~A()     // 析构函数，释放动态分配的空间  
    12.         {  
    13.             if(m_data != NULL)  
    14.             {  
    15.                 delete m_data;  
    16.                 m_data = NULL;  
    17.                 printf("析构函数 ");  
    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("默认构造函数 ");  
    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构造函数 ");  
    18.         }  
    19.   
    20.         ~A()     // 析构函数，释放动态分配的空间  
    21.         {  
    22.             if(m_pdata != NULL)  
    23.             {  
    24.                 delete m_pdata;  
    25.                 printf("析构函数 ");  
    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,  m_pRecValue: %x  m_paddr: %x ", &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  m_pRecValue: %x  m_paddr: %x ",&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   m_pRecValue: %x  m_paddr: %x ", &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  addr: %x  m_paddr: %x ",  &btest.m_stru_RecValue, btest.m_pRecValue,  btest.m_paddr);  
    85.         printf("非参：btest1->&m_stru_RecValue: %x  addr: %x  m_paddr: %x ", &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  m_pRecValue: %x , m_paddr: %x ", &btest2.m_stru_RecValue, btest2.m_pRecValue, btest2.m_  
    94. paddr);  
    95.         printf("带参：btest3->m_stru_RecValue: %x  m_pRecValue: %x , m_paddr: %x ", &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，谢谢合作！
  • 相关阅读:
    如何在android项目中引用project作为类库引用
    Unity3d之MonoBehaviour的可重写函数整理
    Phonegap hello world 不容易啊~！
    数据结构，到底如何用中学，学中用？
    自动化测试（1610）
    软件测试人员的发展路线
    软件测试分类
    我的第一篇博客随笔
    安装虚拟机和Linux系统的学习
    英雄联盟的游戏经验
  • 原文地址：https://www.cnblogs.com/findumars/p/5804860.html
Copyright © 2011-2022 走看看