c/c++整理--复制构造函数和深复制及浅复制

一、复制构造函数是什么？什么是深复制和浅复制？

什么是复制构造函数

　　先来说明什么是复制构造函数，以及它被调用的场合。

　　复制构造函数是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构件及初始化。

　　如果在类中没有显示地声明一个复制构造函数，那么编译器会私下里制定一个函数来进行对象之间的位复制。这个隐含的复制构造函数简单地关联了所有的类成员。

　　在c++中，下面是3种对象需要复制的情况。因此，复制构造函数将会被调用。

（1）一个对象以值传递的方式传入函数体。

（2）一个对象以值传递的方式从函数返回。

（3）一个对象需要通过另外一个对象进行初始化。

下面的程序代码说明了上述三种情况。

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Test  
6. {  
7. public:  
8.     int a;  
9.     Test() { }  
10.     Test(int x)  
11.     {  
12.         a = x;  
13.     }  
14.     Test(Test& test)                            //复制构造函数  
15.     {  
16.         cout<<"copy constructor"<<endl;  
17.         a = test.a;  
18.     }  
19. };  
20.   
21. void fun1(Test test)                            //值传递传入函数体  
22. {  
23.     cout<<"fun1()..."<<endl;  
24. }  
25.   
26. Test fun2()                                     //值传递从函数返回    
27. {  
28.     Test t(2);  
29.     cout<<"fun2()..."<<endl;  
30.     return t;  
31. }  
32.   
33. int main()  
34. {  
35.     Test t1(1);  
36.     Test t2 = t1;                               //用t1对t2进行初始化  
37.     cout<<"before fun1()..."<<endl;  
38.     fun1(t1);  
39.       
40.     Test t3;  
41.     t3 = fun2();  
42.     cout<<"after fun2()..."<<endl;  
43.   
44.     return 0;  
45. }  

运行结果：

[cpp]  view plain  copy

1. copy constructor  
2. before fun1()...  
3. copy constructor  
4. fun1()...  
5. fun2()...  
6. after fun2()...  

fun1、fun2以及代码第36行分别对应了上面三种调用复制构造函数的情况。

深复制与浅复制

　　既然系统会自动提供一个默认的构造函数来处理复制，那么为什么要去自定义复制构造函数呢？下面的程序说明了这个问题。

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <string.h>  
3. using namespace std;  
4.   
5. class Test  
6. {  
7. public:  
8.     char *buf;  
9.     Test(void)                                  //不带参数构造函数  
10.     {  
11.         buf = NULL;  
12.     }  
13.     Test(const char* str)                       //带参数构造函数  
14.     {  
15.         buf = new char[strlen(str)+1];          //分配堆内存  
16.         strcpy(buf, str);                       //复制字符串  
17.     }  
18.     ~Test()  
19.     {  
20.         if(buf != NULL)  
21.         {  
22.             delete buf;                         //释放buf指向的堆内存  
23.             buf = NULL;  
24.         }  
25.     }  
26. };  
27.   
28. int main()  
29. {  
30.     Test t1("hello");  
31.     Test t2 = t1;                               //调用默认的复制构造函数  
32.       
33.     cout<< "(t1.buf == t2.buf) ? " <<(t1.buf == t2.buf ? "yes" : "no") <<endl;  
34.       
35.     return 0;  
36. }  

　　这里Test类的buf成员是一个字符指针，在带参数的构造函数中为之分配了一块堆内存来存放字符串，然后在析构函数中又将堆内存释放。在main函数（代码第31行）使用了对象复制，因此会调用默认的复制构造函数。程序执行结果：

[cpp]  view plain  copy

1. (t1.buf == t2.buf) ? yes  
2. 程序崩溃  

　　这里程序崩溃发生在main函数退出对象析构的时候。由前两行的打印结果可以看出，默认复制构造函数只是简单的把两个对象的指针做复制运算，它们指向的是同一个地址。当产生两次析构，释放同一块内存时发生崩溃。可以在Test类里通过添加一个自定义的复制构造函数解决两次析构问题。

[cpp]  view plain  copy

1. Test(Test& test)  
2. {  
3.     buf = new char[strlen(test.buf)+1];           
4.     strcpy(buf, test.buf);        
5. }  

程序结果如下：

[cpp]  view plain  copy

1. (t1.buf == t2.buf) ? no  

　　由于此时buf又分配了一块堆内存来保存字符串，t1的buf和t2的buf分别指向不同的堆内存，析构时就不会发生程序崩溃。

总结：

　　如果复制的对象中引用了某个外部的内容（例如分配在堆上的数据），那么在复制这个对象的时候，让新旧两个对象指向同一个内容，就是浅复制；如果在复制这个对象的时候，为新对象制作了外部对象的独立复制，那么就是深复制。

　　复制构造函数是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构件及初始化。

　　浅复制是指让新旧两个对象指向同一个外部内容，二深复制就是指为新对象制作了外部对象的独立复制。

二、编译器与默认的copy constructor

　　什么时候编译器会生成默认的copy constructor呢？如果已经写了一个构造函数，编译器还会生成copy constructor吗？

答案：

　　如果用户没有自定义复制构造函数，并且在代码中用到了复制构造函数，那么编译器就会生成默认的复制构造函数；但如果用户定义了复制构造函数，那么编译器就不会再生成复制构造函数。

　　如果用户定义了一个构造函数，且不是复制构造函数，而此时在代码中用到了复制构造函数，那么编译器也还会生成默认的复制构造函数；如果没有使用，则编译器就不会生成默认的复制构造函数。

三、写一个继承类的复制构造函数

　　当然，如果基类中没有私有成员，即所有成员都能被派生类访问，则派生类的复制构造函数可以很容易写。但是如果基类有私有成员，并且这些私有成员必须在调用派生类的复制构造函数时被初始化，在这种情况下该怎么做？

　　编写继承类的复制函数有一个原则：使用基类的复制构造函数。这个原则其实就是解决上述问题的方案。

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Base  
6. {  
7.     int i;  
8. public:  
9.     Base():i(0) { cout<< "Base()"<<endl; }              //默认普通构造函数  
10.     Base(int n):i(n) { cout<< "Base(int)"<<endl; }      //普通构造函数  
11.     Base(const Base& b) : i(b.i)                        //复制构造函数  
12.     {  
13.         cout<<"Base(Base&)"<<endl;  
14.     }  
15. };  
16.   
17. class Deriverd : public Base  
18. {  
19.     int j;  
20. public:  
21.     Deriverd():Base(0), j(0) { cout<< "Deriverd()"<< endl; }  
22.     Deriverd(int m, int n):Base(m), j(n) { cout<< "Deriverd(int)" <<endl; }  
23.     Deriverd(Deriverd &obj):Base(obj), j(obj.j)  
24.     {  
25.         cout<<"Deriverd(Deriverd&)"<<endl;  
26.     }  
27. };  
28.   
29. int main()  
30. {  
31.     Base b(1);  
32.     Deriverd obj(2, 3);  
33.     cout<<"——————————————————"<<endl;  
34.     Deriverd d = obj;  
35.     cout<<"——————————————————"<<endl;     
36.   
37.     return 0;  
38. }  

　　Derived类继承自Base类，因此在Derived类内不能使用obj.i或Base::i的方式访问Base的私有成员i。很明显，其复制构造函数只能使用Base（obj）的方式调用其基类的复制构造函数类给基类的私有生源i初始化。

三、复制构造函数与赋值函数有什么区别？

3个方面：

（1）复制构造函数是一个对象来初始化一块内存区域，这块内存就是新对象的内存区。

[cpp]  view plain  copy

1. class A;  
2. A a;  
3. A b = a;              //复制构造函数调用  
4.   
5. A b(a);               //复制构造函数调用  

而赋值函数是对于一个已经被初始化的对象来进行operator=操作。

[cpp]  view plain  copy

1. class A;  
2. A a;  
3. A b;  
4. b = a;      //赋值函数调用  

（2）一般来说是在数据成员包含指针对象的时候，应付两种不同的处理需求：一种是复制指针对象，一种是引用指针对象。复制构造函数在大多数情况下是复制，赋值函数则是引用对象。

（3）实现不一样。复制构造函数首先是一个构造函数，它调用的时候是通过参数传进来的那个对象来初始化产生一个对象。赋值函数是把一个对象赋给一个原有对象，所以如果原来的对象中有内存分配，要先把内存释放掉，而且还要检查一下两个对象是不是同一个对象，如果是的话，就不做任何操作。