浅拷贝和深拷贝

一、浅拷贝和深拷贝

  所谓浅拷贝，就是由默认的拷贝构造函数所实现的对数据成员逐一赋值。若类中含有指针类型的数据，这种方式只是简单的把指针的指向赋值给新成员，但并没有给新成员分配内存，因此这种方式必然会导致错误。为了解决浅拷贝出现的错误，必须显示的定义一个拷贝构造函数，使之不但复制数据成员，而且为对象分配各自的内存空间，这就是所谓的深拷贝。

二、浅拷贝

  浅拷贝就是由默认的拷贝构造函数所实现的数据成员逐一赋值。通常默认的拷贝构造函数能够胜任这个工作，但是若类中含有指针类型的数据，这种数据成员逐一赋值的方式将会产生错误。

例：

[cpp] view plain copy

 

1. class Student  
2. {  
3. public:  
4.                 Student( char *name ,int age)         //构造函数  
5.                 {  
6.                                 _name = new char [10];           //分配内存  
7.                                 strcpy(_name, name);  
8.                                 _age = age;  
9.                 }  
10.                 ~Student()  
11.                 {  
12.                                  delete[] _name;                 //释放动态内存  
13.                 }  
14.                  void display()  
15.                 {  
16.                                 cout << _name << "--" << _age << endl;  
17.                 }  
18. private:  
19.                  char *_name;  
20.                  int _age;  
21. };  
22.   
23. int main()  
24. {  
25.                  Student st1("lisi" , 20);  
26.                  Student st2(st1);               //调用默认的拷贝构造函数创建一个新的对象  
27.                 system( "pause");  
28.                  return 0;  
29. }  

  程序运行，创建st1时调用构造函数 ，用运算符new从堆上分配一块空间，并用_name指向这块内存空间。在执行st2语句时，因为没有定义拷贝构造函数，所以调用默认的拷贝构造函数：

                Student( Student& st )

                {

                                _name = st._name;                  //并没有为对象st2的数据成员_name分配新的内存空间

                                _age = st._age;

                }

  主程序结束时，对象被逐个撤销，先撤销对象st2(因为st2后创建)，撤销前先调用析构函数，用delete运算符释放所分配的内存空间；撤销对象st1时，第二次调用析构函数，因为这时_name所指向的内存空间已经被释放，企图对同一块内存空间释放两此，所以这时候程序出错。

执行过程如图：

三、深拷贝

 为了解决浅拷贝出现的错误，必须显示的定义一个拷贝构造函数，使之不但能复制数据成员，而且为指针分配各自的动态内存。

例：

[cpp] view plain copy

 

1. class Student  
2. {  
3. public:  
4.                 Student( char *name ,int age)         //构造函数  
5.                 {  
6.                                 _name = new char [10];           //分配内存  
7.                                 strcpy(_name, name);  
8.                                 _age = age;  
9.                 }  
10.                 Student( Student& st )                 //自定义的拷贝构造函数  
11.                 {  
12.                                 _name = new char [10];  
13.                                  if (_name != NULL )  
14.                                 {  
15.                                                 strcpy(_name, st._name);  
16.                                                 _age = st._age;  
17.                                 }  
18.                 }  
19.                 ~Student()  
20.                 {  
21.                                  delete[] _name;                 //释放动态内存  
22.                 }  
23.                  void display()  
24.                 {  
25.                                 cout << _name << "--" << _age << endl;  
26.                 }  
27. private:  
28.                  char *_name;  
29.                  int _age;  
30. };  
31.   
32. int main()  
33. {  
34.                  Student st1("lisi" , 20);  
35.                  Student st2(st1);               //调用默认的拷贝构造函数创建一个新的对象  
36.                 system( "pause");  
37.                  return 0;  
38. }  

在执行Student st2(st1)时调用自定义的拷贝构造函数，为st2._name分配自己的动态内存。程序的执行过程如图：

转载地址：http://blog.csdn.net/lf_2016/article/details/51985464?ref=myread

顶

2

 

踩

1