加载中…
个人资料
微博
  • 博客等级：
  • 博客积分：
  • 博客访问：
  • 关注人气：
  • 获赠金笔：0支
  • 赠出金笔：0支
  • 荣誉徽章：
正文 字体大小：大 中 小

浅复制和深复制的区别

(2016-05-22 23:57:21)
标签：

it

     用一句简单的话来说就是浅拷贝，只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

 

    浅拷贝会出现什么问题呢？

假如有一个成员变量的指针，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   
  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   
  2. #include   
  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   
  2. #include   
  3. #include   
  4. #include   
  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.   
  33.                 //构造函数  
  34.                 recorder(int iId, int iAge)  
  35.                 {  
  36.                         m_stru_RecValue.Id = iId;  
  37.                         m_stru_RecValue.Age = iAge;  
  38.                         m_pRecValue = &m_stru_RecValue;  
  39.   
  40.                         m_paddr = new char[100];  
  41.                         memset(m_paddr, 0x00 ,100);  
  42.                         memcpy(m_paddr, &iAge, sizeof(int));  
  43.   
  44.                         printf("construct recorder->&m_stru_RecValue: %x \t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecValue,  
  45. m_paddr);  
  46.                 }  
  47.   
  48.                 ~recorder()  
  49.                 {  
  50.                 //      cout<<"recorder 析构"<<endl;  
  51.                           
  52.                 }  
  53.   
  54.         public:  
  55.                 RECODER_VALUE_STRU m_stru_RecValue;//存储记录信息的结构体   
  56.                 void* m_pRecValue;//每条记录的值  
  57.                 char *m_paddr;  
  58. };  
  59.   
  60. int main()  
  61. {  
  62.         cout <<"测试默认构造函数"<<endl<<endl;  
  63.         recorder btest;  
  64.         recorder btest1(btest);  
  65.   
  66.         printf("非参：btest ->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n",  &btest.m_stru_RecValue, btest.m_pRecValue,  btest.m_paddr);  
  67.         printf("非参：btest1->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n", &btest1.m_stru_RecValue, btest1.m_pRecValue, btest1.m_paddr);  
  68.   
  69.   
  70.         cout << endl<<"测试带参数的构造函数"<<endl<<endl;  
  71.   
  72.   
  73.         recorder btest2(1, 100);  
  74.         recorder btest3(btest2);  
  75.         printf("带参：btest2->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest2.m_stru_RecValue, btest2.m_pRecValue, btest2.m_  
  76. paddr);  
  77.         printf("带参：btest3->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest3.m_stru_RecValue, btest3.m_pRecValue, btest3.m_  
  78. paddr);  
  79.   
  80.   
  81.         return 0;  
  82. }  

对比结果：

注释掉自定义拷贝构造函数,运行结果：

测试默认构造函数

 

默认 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. }  

喜欢

0

阅读┊ 收藏 ┊ 喜欢▼ ┊打印┊举报/Report
  

新浪BLOG意见反馈留言板　欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

Copyright © 1996 - 2022 SINA Corporation, All Rights Reserved

新浪公司 版权所有