C++复制构造函数

 什么是复制构造函数：

复制构造函数是一种特殊的构造函数，顾名思义就是用于复制一个对象。主要出现在以下3种情况：

（1）对象以值传递的形式作为函数参数。

（2）对象以值传递的形式作为函数返回值。

（2）用一个对象实例初始化一个新建对象。

复制构造函数的参数列表必须包含一个该类对象的引用而且可以包含有默认值的其他参数如：

现有类

class test{
public:
	test(){}//构造函数
	test(test& x){} //复制构造函数
	test(const test& x){} //复制构造函数
	test(const test& x , int i = 0 , int j =1){} //复制构造函数，除了对象引用之外还有其他含有默认值参数，这样的构造函数也是复制构造函数
	test(const test& x , int i , int j){} //不是复制构造函数
private:
	int i;
	int j;
};

对象以值传递的形式作为函数参数：

#include <iostream>
using namespace std;
class test{
public:
	test(){}//构造函数
	test(test& x){ cout<<"复制构造函数执行"<<endl; } //复制构造函数
private:
	int i;
	int j;
};

void fun(test a){  //函数参数为以值传递形式的test对象
}

void main(){
	test a;
	fun(a);
}

对象以值传递的形式作为函数的返回值：

#include <iostream>
using namespace std;
class test{
public:
	test(){}//构造函数
	test(test& x){ cout<<"复制构造函数执行"<<endl; } //复制构造函数
private:
	int i;
	int j;
};

test fun(){  //函数参数为以值传递形式的test对象
	test a;
	return a;
}

void main(){
	fun();
}

用于对象的初始化：

#include <iostream>
using namespace std;
class test{
public:
	test(){}//构造函数
	test(test& x){ cout<<"复制构造函数执行"<<endl; } //复制构造函数
private:
	int i;
	int j;
};


void main(){
	test a;
	test b(a);  // b(a)与 test b = a等效
	test c = a;
}

什么时候需要自定义复制构造函数？

当类的成员变量包含指针或静态变量时需要考虑自定义复制构造函数，要知道如果不自定义复制构造函数，编译器会提供一个默认的复制构造函数，以上面的test类为例，编译器会自动提供形式为test(test & x);或者test(const test & x);这种形式的复制构造函数，功能是简单的成员变量赋值操作：

test(test &x){
   this.i = x.i;
   this.j = x.j;
}

如果成员变量为指针或静态变量时，也仅仅是简单的赋值操作，这是很危险的。以成员指针为例：

#include <iostream>
using namespace std;
class test{
public:
	test(){int *a = new int(1); p = a;}  //构造函数
	~test(){delete p;} //析构函数
private:
	int *p;
};


void main(){
	test a;
	test b(a);  /*调用默认的复制构造函数函数使得a和b中的成员指针p都指向同一块堆空间
				  在程序结束后会先析构b对象释放b中p所指向的堆空间，接着析构a对象释放a中p
				  所指向的堆空间，然而a和b指向的是同一块堆空间，造成了二次释放，所以程序
				  运行会出现错误
				  */
}

当成员变量包含静态变量时，也要注意自定义复制构造函数

#include <iostream>
using namespace std;
class test{
public:
	test(){i++;}  
	static int i; //统计创建的对象数，每创建一个对象i就加1
};

int test::i = 0;
void main(){
	test a;
	test b;
	cout<<b.i<<endl; //已经创建了2个对象，i的值应该为2
	test c = a; //调用默认的复制构造函数
	cout<<c.i<<endl; //创建了3个对象，i的值按道理应该为3，但实际却为2
}

创建C对象时，调用了默认的复制构造函数而没有调用构造函数，所以没有实现静态变量的变化，完成的仅仅是变量的赋值操作，因而创建3个对象后，i的值仍然为2.

赋值运算与复制构造函数的区别：

#include <iostream>
using namespace std;
class test{
public:
	test(){ cout<<"构造函数执行"<<endl;}//构造函数
	test(test& x){ cout<<"复制构造函数执行"<<endl; } //复制构造函数
private:
	int i;
	int j;
};

void main(){
	test a,c;  //创建了2个对象
	test b = a; //调用复制构造函数
	a = c; //没有调用复制构造函数，但完成了成员变量的赋值操作
}

运行后构造函数执行了2次，复制构造函数执行了1次。可见a=c这种赋值操作，并没有调用复制构造函数。

对象之间的赋值运算是指两个已经实例化的对象之间的一种运算，默认完成成员变量之间的赋值操作与默认的复制构造函数的功能相似，但并没有创建新的对象。而复制构造函数是为了创建并初始化一个对象，这是两者根本的区别。如果成员变量包含指针或静态变量，要对赋值操作符进行重载，具体原因上面已经介绍过。