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