浅拷贝深拷贝

Bertha 。 2022-07-15 00:28 258阅读 0赞

# 对深拷贝与浅拷贝的再次理解 #

记得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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][http_blog.csdn.net_feitianxuxue]，谢谢合作

[view plain]: http://blog.csdn.net/feitianxuxue/article/details/9275979#
[http_blog.csdn.net_feitianxuxue]: http://blog.csdn.net/feitianxuxue

浅拷贝深拷贝

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关深拷贝和浅拷贝

相关深拷贝浅拷贝

相关深拷贝/浅拷贝

相关深拷贝和浅拷贝

相关浅拷贝和深拷贝

相关浅拷贝深拷贝

相关深拷贝，浅拷贝

相关浅拷贝和深拷贝

相关深拷贝浅拷贝

相关浅拷贝和深拷贝