C++深复制和浅复制

转载自http://blog.csdn.net/sxhelijian/article/details/23209967

对象的复制

 　　对于普通类型的对象来说，它们之间的复制是很简单的，例如：

[cpp] view plain copy print?

1. int a=88;  
2. int b=a;  
3. double f=3.12;  
4. double d(f);  

　　而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种数据成员。下面看一个类对象复制的简单例子。

[cpp] view plain copy print?

1. #include <iostream>  
2. using namespace std;  
3. class Test  
4. {  
5. private:  
6.     int a,b;  
7. public:  
8.     Test(int x, int y)     //提供的形式参数，是为了给数据成员直接初始化的  
9.     {  
10.         a=x;  
11.         b=y;  
12.     }  
13.     Test(const Test& C)   //复制构造函数，提供一个同类型对象作为参数  
14.     {  
15.         a=C.a;  
16.         b=C.b;  
17.     }  
18.     void show ()  
19.     {  
20.         cout<<a<<"  "<<b<<endl;  
21.     }  
22. };  
23.    
24. int main()  
25. {  
26.     Test a(100,10);    //执行构造函数Test::Test(int x, int y)  
27.     Test b(a);      //执行构造函数Test::Test(const Test& C)  
28.     Test c=a;      //也执行构造函数Test::Test(const Test& C)  
29.     b.show();  
30.     c.show();  
31.     return 0;  
32. }  

　　运行程序，屏幕输出两行100   10。

　　从以上代码的运行结果可以看出，系统在声明对象b和c时，完成了由对象a的复制。

 复制构造函数

　　就类对象而言，相同类型的类对象是通过复制构造函数来完成整个复制过程的。

　　上例中的Test::Test(const Test& C)，就是我们自定义的复制构造函数。

　　可见，复制构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，用来约束作为参数的对象在构造新对象中是不能被改变的。

　　略一归纳：类X的复制构造函数的形式为X(X& x)。

　　当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，复制构造函数就会被自动调用。也就是说，当类的对象需要复制时，复制构造函数将会被调用。以下情况都会调用复制构造函数：

• 一个对象以值传递的方式传入函数体
• 一个对象以值传递的方式从函数返回
• 一个对象需要通过另外一个对象进行初始化。

　　如果在类中没有显式地声明一个复制构造函数，那么，编译器将会自动生成一个默认的复制构造函数，该构造函数完成对象之间的浅复制，后面将进行说明。

　　自定义复制构造函数是一种良好的编程风格，它可以阻止编译器形成默认的复制构造函数，提高源码效率。

 浅复制和深复制

　　所谓浅复制，如同上面出现过的构造函数中处理的一样，直接为数据成员赋值即可。在很多情况下，这是可以的。创建新的对象，要为对象的数据成员分配存储空间，直接赋值就将值保存在相应的空间中。

　　然而，这种浅复制，却并不能通行天下，下面的程序中，浅复制带来了问题。

[cpp] view plain copy print?

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4. class Test  
5. {  
6. private:  
7.     int a;  
8.     char *str;  
9. public:  
10.     Test(int b, char *s)  
11.     {  
12.         a=b;  
13.         strcpy(str,s);  //肇事地点，但不是祸端  
14.     }  
15.     Test(const Test& C)  
16.     {  
17.         a=C.a;  
18.         strcpy(str,C.str);  
19.     }  
20.     void show ()  
21.     {  
22.         cout<<a<<","<<str<<endl;  
23.     }  
24. };  
25.    
26. int main()  
27. {  
28.     Test a(100,"hello");  
29.     Test b(a);  
30.     a.show();  
31.     b.show();  
32.     return 0;  
33. }  

　　程序运行中，会弹出一个窗口：程序的执行意外停止了。面对这个窗口，我们应该有感觉，这和使用指针不当有关系。

　　我们从main函数看起。

　　当程序执行到第28行Test a(100,"hello");时，对象a的数据成员a获得实际参数100的值，而数据成员str，即指针，是个随机地址值（指针的值，非指针指向的值）！在程序中，试图通过strcpy(str,s);将形式参数s指向的字符串"hello"，复制到str所指向的那个位置，而那个位置，其地址并不是经过系统分配来的，这是个危险的操作。在这里，str这样未经过分配的地址（指针），被称为“野指针”。

　　在执行第29行Test b(a);时，同样的事情还要发生。

　　str这样的野指针是多么的霸道！在有的系统里，这样的行为是被接受的，可以想到其有多危险。有些系统中，不允许这样的事情发生的。于是，上面的程序在codeblock中调试会出错。这个错来的好。

　　解决这样的问题的方法，就是在构造函数中，要为指针类型的成员，分配专门的空间。以这条规则构建的复制，称作为深复制！

　　上面的程序，改写为：

[cpp] view plain copy print?

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4. class Test  
5. {  
6. private:  
7.     int a;  
8.     char *str;  
9. public:  
10.     Test(int b, char *s)  
11.     {  
12.         a=b;  
13.         str=new char[strlen(s)+1];  //分配str指向的空间，其长度根据s指向的字符串定。为何加1？字符串结束要用\0  
14.         strcpy(str,s);  //前一程序的肇事地点，祸端已经由上一句摘除  
15.     }  
16.     Test(const Test& C)  
17.     {  
18.         a=C.a;  
19.         str=new char[strlen(C.str)+1];   //同上，这样str就不是野指针了  
20.         strcpy(str,C.str);  
21.     }  
22.     ~Test()  
23.     {  
24.         delete []str;  
25.     }  
26.     void show ()  
27.     {  
28.         cout<<a<<","<<str<<endl;  
29.     }  
30. };  
31.   
32. int main()  
33. {  
34.     Test a(100,"hello");  
35.     Test b(a);  
36.     a.show();  
37.     b.show();  
38.     return 0;  
39. }  

　　好了，a和b对象的str成员，明确地给分配了空间，他们再不是野指针了。因为明确地分配了空间， 析构函数中要释放对应的空间 。我们不能用野指针，当然，也不能对象要撤销了，还占着空间不放，做事不能这样不厚道。

　　深复制就体现在第13和第19行分配指针指向的空间，这段空间的地址，也将是指针的值（分清指针的值和指针指向的值）。

再一个深复制的例子

　　下面再给一个例子，类A的数据成员可以保存len个整型数据。类中的数据成员arrayAddr是指向整型的指针，可以作为一个一元数组的起始地址。这个类有指针数据成员，构造函数的定义中，必须要采用深复制的方法，第16行体现了这一点。另外，析构函数中完成了对分配的空间的释放

[cpp] view plain copy print?

1. #include<iostream>  
2. using namespace std;  
3. class A  
4. {  
5. private:  
6.     int *arrayAddr;//保存一个有len个整型元素的数组的首地址  
7.     int len;       //记录动态数组的长度  
8. public:  
9.     A(int *a, int n);  
10.     ~A();  
11.     int sum();  
12. };  
13. A::A(int *a, int n)  
14. {  
15.     len=n;  
16.     arrayAddr=new int[n];  //为指针数据成员分配空间，注意，没有上面例子中加1那回事  
17.     for(int i=0; i<n; i++)  //逐个地将a指向的值逐个地复制过来  
18.     {  
19.         arrayAddr[i]=a[i];  
20.     }  
21. }  
22. //析构函数的类外定义，释放指针型数据a所指向的空间  
23. A::~A()  
24. {  
25.     delete [] arrayAddr;  
26. }  
27. int A::sum()   //获得a指向的数组中下标为i的元素的值  
28. {  
29.     int s=0;  
30.     for(int i=0; i<len; i++)  //逐个地将a指向的值逐个地复制过来  
31.     {  
32.         s+=arrayAddr[i];  
33.     }  
34.     return s;  
35. }  
36.   
37. int main(){  
38.     int b[10]= {75, 99, 90, 93, 38, 15, 5, 7, 52, 4};  
39.     A r1(b,10);  
40.     cout<<"和："<<r1.sum()<<endl;  
41.     int c[15] = {18,68,10,52,3,19,12,100,56,96,95,97,1,4,93};  
42.     A r2(c,15);  
43.     cout<<"和："<<r2.sum()<<endl;  
44.     return 0;  
45. }