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

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

什么是复制构造函数

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

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

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

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

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

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

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

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

#include <iostream>using namespace std;class Test{public:int a;Test() { }Test(int x){a = x;}Test(Test& test)//复制构造函数{cout<<"copy constructor"<<endl;a = test.a;}};void fun1(Test test)//值传递传入函数体{cout<<"fun1()..."<<endl;}Test fun2()//值传递从函数返回{Test t(2);cout<<"fun2()..."<<endl;return t;}int main(){Test t1(1);Test t2 = t1;//用t1对t2进行初始化cout<<"before fun1()..."<<endl;fun1(t1);Test t3;t3 = fun2();cout<<"after fun2()..."<<endl;    return 0;}

运行结果：

copy constructorbefore fun1()...copy constructorfun1()...fun2()...after fun2()...

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

深复制与浅复制

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

#include <iostream>#include <string.h>using namespace std;class Test{public:char *buf;Test(void)//不带参数构造函数{buf = NULL;}Test(const char* str)//带参数构造函数{buf = new char[strlen(str)+1];//分配堆内存strcpy(buf, str);//复制字符串}~Test(){if(buf != NULL){delete buf;//释放buf指向的堆内存buf = NULL;}}};int main(){Test t1("hello");Test t2 = t1;//调用默认的复制构造函数cout<< "(t1.buf == t2.buf) ? " <<(t1.buf == t2.buf ? "yes" : "no") <<endl;    return 0;}

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

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

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

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

程序结果如下：

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

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

总结：

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

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

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

二、编译器与默认的copy constructor

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

答案：

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

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

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

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

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

#include <iostream>using namespace std;class Base{int i;public:Base():i(0) { cout<< "Base()"<<endl; }//默认普通构造函数Base(int n):i(n) { cout<< "Base(int)"<<endl; }//普通构造函数Base(const Base& b) : i(b.i)//复制构造函数{cout<<"Base(Base&)"<<endl;}};class Deriverd : public Base{int j;public:Deriverd():Base(0), j(0) { cout<< "Deriverd()"<< endl; }Deriverd(int m, int n):Base(m), j(n) { cout<< "Deriverd(int)" <<endl; }Deriverd(Deriverd &obj):Base(obj), j(obj.j){cout<<"Deriverd(Deriverd&)"<<endl;}};int main(){Base b(1);Deriverd obj(2, 3);cout<<"——————————————————"<<endl;Deriverd d = obj;cout<<"——————————————————"<<endl;    return 0;}

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

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

3个方面：

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

class A;A a;A b = a;              //复制构造函数调用A b(a);               //复制构造函数调用

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

class A;A a;A b;b = a;      //赋值函数调用

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

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