默认拷贝构造函数 与 自定义拷贝构造函数

拷贝构造

有Person类如下：

class Person
{
	char* pName;
public:
	Person(char* pN="noName")
	{
	cout<<"Constructing "<<pN<<endl;
	pName=new char[strlen(pN)+1];
	if(pName) strcpy(pName,pN);
	}
	~Person()
	{
	cout<<"Destructing "<<pName<<endl;
	delete[] pName;
	}
};

类似整型变量 b 在定义时复制变量 a 的形式，我们希望对象也可以通过类似的形式来创建，这种对象的创建活动称为 拷贝构造.

int a=3;
int b=a;
Person x("UncleThompson");
Person y=x;

默认拷贝构造函数

下列程序实现了一个拷贝构造：

#include<iostream>
using namespace std;
class Person
{
	char* pName;
public:
	Person(char* pN="noName")
	{
	cout<<"Constructing "<<pN<<endl;
	pName=new char[strlen(pN)+1];
	if(pName) strcpy(pName,pN);
	}
	~Person()
	{
	cout<<"Destructing "<<pName<<endl;
	delete[] pName;
	}
};
int main()
{
	Person p1("Randy");
	Person p2(p1); //拷贝语句
}

运行结果输出如下，没有第二次输出“Constructing Randy”，说明在创建 p2 的时候并没有调用Person的默认构造，而且析构函数的表现也不正常。

Constructing Randy
Destructing Randy
Destructing 恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰恰

原因是对象进行了C++的默认拷贝构造，复制情况如下图所示，先析构 p2（对象构造与析构的关系是栈数据结构中的入栈和出栈的关系，所以对象析构的顺序与对象创建的顺序正好相反），将存有Randy的空间先行释放，轮到 p1析构时，Randy已经不存在了，因此会出现不可预料的怪异结果。

自定义拷贝构造函数

为了达到对 对象的整体 进行复制的目的，另外定义一个拷贝构造函数，以覆盖默认的拷贝构造函数：

#include<iostream>
using namespace std;
class Person
{
	char* pName;
public:
	Person(char* pN="noName")
	{
	cout<<"Constructing "<<pN<<endl;
	pName=new char[strlen(pN)+1];
	if(pName) strcpy(pName,pN);
	}
	
	Person(const Person& s)  //参数是类对象的常量引用
	{
		cout<<"copy Constructing "<<s.pName<<endl;
		pName=new char[strlen(s.pName)+1];
		if(pName) strcpy(pName,s.pName);
	}
	~Person()
	{
	cout<<"Destructing "<<pName<<endl;
	delete[] pName;
	}
};
int main()
{
	Person p1("Randy");
	Person p2(p1); //拷贝语句
}

运行结果输出如下：

Constructing Randy
copy Constructing Randy
Destructing Randy
Destructing Randy

自定义拷贝构造函数是构造函数的重载，一旦定义了拷贝构造函数，默认的拷贝构造函数就不再起作用。自定义拷贝构造函数的参数必须是类对象的常量引用：

Person(const Person& s)  //参数不是类对象的常量引用

如果被复制的对象是常对象:

const Person p1("Jone");
Person p2(p1);

而拷贝构造函数的参数不是常量引用，

Person(Person& s)  //参数不是类对象的常量引用

就相当于 置一个常对象在可能被修改的危险之中，编译的时候会出现如下错误：