复制构造函数

调用复制构造函数的情形
在C++中，下面三种对象需要调用复制构造函数：
1) 一个对象作为函数参数，以值传递的方式传入函数体；
2) 一个对象作为函数返回值，以值传递的方式从函数返回；
3) 一个对象用于给另外一个对象进行初始化（常称为赋值初始化）；

4)编译器生成临时对象

 

一、一个对象作为函数参数，以值传递的方式传入函数体

二、一个对象作为函数返回值，以值传递的方式从函数返回

#include <iostream>
using namespace std;

class A
{
public:
	A(){cout<<"构造函数执行中"<<endl;}
	A(A&){cout<<"复制构造函数执行中"<<endl;}
	~A(){cout<<"析构函数执行中"<<endl;}
};

A func(A once)
{
	printf("测试一下\n");
	//函数参数按值传递参数会执行一次复制构造函数和一次析构函数
	//函数返回是按值返回对象,也会执行一次复制构造函数和一次析构函数
	return once;
}

int main (void)
{
	A a;
	cout<<"------------------------"<<endl;
	func(a);
	cout<<"------------------------"<<endl;
	return 0;
}
/*
2015年3月3日23:21:44
程序执行结果如下:
构造函数执行中
------------------------
复制构造函数执行中
测试一下
复制构造函数执行中
析构函数执行中
析构函数执行中
------------------------
析构函数执行中
请按任意键继续. . .
*/

 

三、一个对象用于给另外一个对象进行初始化（常称为赋值初始化）；

#include <iostream>
using namespace std;

//一个对象用于给另外一个对象进行初始化（常称为赋值初始化）；
class A
{
public:
	A(){cout<<"构造函数执行中"<<endl;}
	A(A&){cout<<"复制构造函数执行中"<<endl;}
	~A(){cout<<"析构函数执行中"<<endl;}


};

int main (void)
{
	A a;
	A b=a;    //一个对象赋值给另外一个对象，会调用复制构造函数
	return 0;
}
/*
2015年3月3日23:23:46
程序执行结果如下:
构造函数执行中
复制构造函数执行中
析构函数执行中
析构函数执行中
请按任意键继续. . .
*/

 

四、按地址传递对象

#include <iostream>
using namespace std;

class A
{
public:
	A(){cout<<"构造函数执行中"<<endl;}
	A(A&){cout<<"复制构造函数执行中"<<endl;}
	~A(){cout<<"析构函数执行中"<<endl;}
};

A* func(A *once)
{
	printf("测试一下\n");
	//函数参数按地址传递参数不会执行复制构造函数和析构函数
	//函数返回是按地址返回,不会执行复制构造函数和析构函数
	return once;
}

int main (void)
{
	A a;
	cout<<"------------------------"<<endl;
	func(&a);
	cout<<"------------------------"<<endl;
	return 0;
}
/*
2015年3月3日23:25:04
程序执行结果如下:
构造函数执行中
------------------------
测试一下
------------------------
析构函数执行中
请按任意键继续. . .
*/

 

五、使用const指针来传递对象

#include <iostream>
using namespace std;

class A
{
public:
	A(){cout<<"构造函数执行中"<<endl;}
	A(A&){cout<<"复制构造函数执行中"<<endl;}
	~A(){cout<<"析构函数执行中"<<endl;}

	int getx(void)const {return x;} //函数体前面加上const表示该函数不会修改对象的值
	void setx(int i){x=i;}
private:
	int x;
};

const A* const func(const A * const once)
{
	once->getx();
	//once->setx(12); //修改对象的值
	//加上const是保证对象不被修改
	return once;
}

int main (void)
{
	A a;
	const A* const p=func(&a);
	a.setx(12);
	//p->setx(11);  //不能修改const对象的值
	cout<<p->getx()<<endl;

	return 0;
}
/*
2015年3月3日23:26:02
程序执行结果如下:
构造函数执行中
12
析构函数执行中
请按任意键继续. . .
*/

 

六、深层复制构造函数

#include <iostream>
using namespace std;


class A
{
public:
	A(){x=new int;*x=5;}
	A(const A& a);
	~A(){delete x;x=NULL;}
	void setx(int a){*x=a;}
	void print(void)const {cout<<*x<<endl;}  //前面加const防止修改变量的值
private:
	int *x;
};
A::A(const A& a)   //const表示限制对传递进来的对象进行修改
{
	cout<<"复制构造函数执行中"<<endl;
	x=new int;
	*x=*(a.x);
}

int main (void)
{
	
	cout<<"堆中构造a对象，x的值"<<endl;
	A *a=new A;
	a->print();

	cout<<"堆中a对象赋值给b对象后b对象x的值"<<endl;
	A b=*a;
	b.print();

	cout<<"a对象设置x的值为12后"<<endl;
	a->setx(12);
	cout<<"a对象x的值";
	a->print();
	cout<<"b对象x的值";
	b.print();

	cout<<"b对象设置x的值为14后"<<endl;
	b.setx(14);
	cout<<"a对象x的值";
	a->print();
	cout<<"b对象x的值";
	b.print();

	delete a;
	cout<<"删除a对象后输出b对象的x的值";
	b.print();
	
	cout<<"----------------------------"<<endl;
	{
		A a;
		a.print();
		A b=a;
		b.print();
	}
	cout<<"----------------------------"<<endl;

	return 0;
}
/*
2015年3月3日23:28:11
程序执行结果如下:
堆中构造a对象，x的值
5
堆中a对象赋值给b对象后b对象x的值
复制构造函数执行中
5
a对象设置x的值为12后
a对象x的值12
b对象x的值5
b对象设置x的值为14后
a对象x的值12
b对象x的值14
删除a对象后输出b对象的x的值14
----------------------------
5
复制构造函数执行中
5
----------------------------
请按任意键继续. . .
*/