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

拷贝构造

有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
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已经不存在了,因此会出现不可预料的怪异结果。
默认拷贝构造函数 与 自定义拷贝构造函数_第1张图片

自定义拷贝构造函数

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

#include
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)  //参数不是类对象的常量引用

就相当于 置一个常对象在可能被修改的危险之中,编译的时候会出现如下错误:
默认拷贝构造函数 与 自定义拷贝构造函数_第2张图片

你可能感兴趣的:(C++)