C++ 拷贝构造函数中浅拷贝与深拷贝
2018-03-07 23:43
295 查看
浅拷贝构造函数
看一段拷贝构造函数的代码
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
类Array实例化一个arr1的对象,并给数据成员m_iCount赋值为5。
接着类Array实例化一个对象arr2并将arr1的数据成员的值拷贝给arr2
运行代码,显然arr1和arr2的数据成员m_iCount的值都为5,系统给arr1,arr2分配了内存空间并使得arr1的值复制给了arr2
接下来再看一段代码:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
我们在类中添加一个数据成员int型的指针m_pArr,实例化一个对象arr1并给数据成员m_iCount赋值为5,与此同时系统也需要给另一个数据成员m_pArr在堆区分配内存空间
接着实例化一个对象arr2并将arr1的值复制给arr2,系统调用拷贝构造函数。将arr1.m_iCount赋值给arr2.m_iCount,将arr1.m_pArr赋值给arr2.m_iArr。因为在拷贝构造函数中,系统并没有在堆区分配一个内存空间给arr2的数据成员m_iArr。所以这里两个对象的数据成员m_iArr显然都指向了同一块内存空间,那么会有什么问题呢?
当我们在调用析构函数,释放内存空间的时候,两个对象指向的那块内存空间就会被释放两次,这样程序会奔溃,导致出错。
这就是浅拷贝带来的危险
这里再引入深拷贝:
2
3
4
5
6
当类中存在数据成员需要动态开辟内存空间的时候,需要使用深拷贝的方式区别:
在某些状况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。 深拷贝和浅拷贝可以简单理解为:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝,反之,没有重新分配资源,就是浅拷贝。
看一段拷贝构造函数的代码
#include <iostream> #include <cstring> using namespace std; class Array{ public : Array(){ cout<<"Array()"<<endl; } Array(const Array &arr){ /// 拷贝构造函数 m_iCount = arr.m_iCount; cout<<"Array &"<<endl; } virtual ~Array(){ cout<<"~Array()"<<endl; } void setCount(int _count){ m_iCount = _count; } int getCount(){ return m_iCount; } private : int m_iCount; }; int main(){ Array arr1; arr1.setCount(5); Array arr2(arr1);///浅拷贝 cout<<"arr2 m_iCount "<<arr2.getCount()<<endl; return 0; }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
类Array实例化一个arr1的对象,并给数据成员m_iCount赋值为5。
接着类Array实例化一个对象arr2并将arr1的数据成员的值拷贝给arr2
运行代码,显然arr1和arr2的数据成员m_iCount的值都为5,系统给arr1,arr2分配了内存空间并使得arr1的值复制给了arr2
接下来再看一段代码:
#include <iostream> #include <cstring> using namespace std; class Array{ public : Array(int _count){ m_iCount = _count; m_pArr = new int[m_iCount]; cout<<"Array()"<<endl; } Array(const Array &arr){ /// 拷贝构造函数 m_iCount = arr.m_iCount; m_pArr = arr.m_pArr; ///两个指针指向同一块内存 cout<<"Array &"<<endl; } virtual ~Array(){ delete []m_pArr; m_pArr = NULL; cout<<"~Array()"<<endl; } void setCount(int _count){ m_iCount = _count; } int getCount(){ return m_iCount; } void printAddr(){ cout<<"m_pArr : "<<m_pArr<<endl; } private : int m_iCount; int *m_pArr; }; int main(){ Array arr1(5); Array arr2(arr1); arr1.printAddr(); arr2.printAddr(); return 0; }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
我们在类中添加一个数据成员int型的指针m_pArr,实例化一个对象arr1并给数据成员m_iCount赋值为5,与此同时系统也需要给另一个数据成员m_pArr在堆区分配内存空间
接着实例化一个对象arr2并将arr1的值复制给arr2,系统调用拷贝构造函数。将arr1.m_iCount赋值给arr2.m_iCount,将arr1.m_pArr赋值给arr2.m_iArr。因为在拷贝构造函数中,系统并没有在堆区分配一个内存空间给arr2的数据成员m_iArr。所以这里两个对象的数据成员m_iArr显然都指向了同一块内存空间,那么会有什么问题呢?
当我们在调用析构函数,释放内存空间的时候,两个对象指向的那块内存空间就会被释放两次,这样程序会奔溃,导致出错。
这就是浅拷贝带来的危险
这里再引入深拷贝:
Array(const Array &arr){ /// 拷贝构造函数 m_iCount = arr.m_iCount; m_pArr = new int[m_iCount]; for(int i=0;i<m_iCount;i++) m_pArr[i]=arr.m_pArr[i]; cout<<"Array &"<<endl; }1
2
3
4
5
6
当类中存在数据成员需要动态开辟内存空间的时候,需要使用深拷贝的方式区别:
在某些状况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。 深拷贝和浅拷贝可以简单理解为:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝,反之,没有重新分配资源,就是浅拷贝。
相关文章推荐
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- c++拷贝构造函数(深拷贝和浅拷贝)
- C++拷贝构造函数(深拷贝与浅拷贝)详解
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝与浅拷贝)详解
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝、浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝、浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)
- c++中 拷贝构造函数的深拷贝和浅拷贝--“浅拷贝”与“深拷贝”
- C++拷贝构造函数(深拷贝,浅拷贝)
- C++拷贝构造函数(深拷贝,浅拷贝)[难得一篇写得很易懂的C++文章]
- C++拷贝构造函数(深拷贝,浅拷贝)参考二
- C++拷贝构造函数(深拷贝,浅拷贝)