拷贝构造函数

定义

拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。

是特殊的构造函数
如果一个类没有添加拷贝构造函数，那么编译器将自动生成一个拷贝构造函数，实现是浅拷贝
如果一个类需要实现深拷贝，则需要自己添加拷贝构造函数
拷贝构造函数形如：
class CLA_NAME{
	CLA_NAME(const CLA_NAME& otherobj){//形参的const和&(引用)都不能省
		
	}
};

在C++中，下面三种对象需要调用拷贝构造函数（有时也称“复制构造函数”）：

1. 一个对象作为函数参数，以值传递的方式传入函数体；
2. 一个对象作为函数返回值，以值传递的方式从函数返回；
3. 一个对象用于给另外一个对象进行初始化（常称为赋值初始化）；

注意

如果在前两种情况不使用拷贝构造函数的时候，就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是拷贝构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作符共同实现的。

	拷贝构造函数没有返回值  也不是void
	拷贝构造函数名字和类名相同
	拷贝构造函数的形参只有一个  同类型的  引用对象   必须是引用
拷贝构造函数什么时候调用:
	当用一个已经存在的对象去实例化一个同类型的对象时，调用的是拷贝构造函数

浅拷贝和深拷贝:

	浅拷贝就是按字节拷贝，即对象中的成员属性进行按字节复制，
		如果对象中有指针成员，就是把指针的值进行了拷贝(拷贝之后，两个指针指向同一块内存)
	深拷贝就是拷贝指针所指向的内容，而不是拷贝指针变量本身的值

默认的拷贝构造函数：
	依次调用父类类型的拷贝构造函数(按继承顺序)
	依次调用类类型成员的拷贝构造函数(按成员定义顺序)
	本类类型的拷贝构造函数

如果自己实现拷贝构造函数需要注意的问题:
	(1)需要实现父类成员的拷贝  在初始化列表中调用父类的拷贝构造函数  
			如果在初始化列表中没有调用父类的拷贝构造，则默认调用无参构造
	(2)需要实现类类型成员的拷贝 在初始化列表中调用类类型成员的拷贝构造函数
			如果在初始化列表中没有调用类类型成员的拷贝构造，则默认调用无参构造
	(3)需要实现本类中其它成员的拷贝 

代码实现浅拷贝

#include <iostream>
using namespace std;

class Test{
public:
	Test(){
		cout << "Test()构造函数" << endl;	
	}
	//拷贝构造函数 如果自己不实现，编译器自动添加 实现方式浅拷贝
	Test(const Test& o){
		cout << "copy构造函数" << endl;
	}
	~Test(){
		cout << "~Test()析构函数" << endl;	
	}
};

Test getTest(){
	Test t;
	return t;
}
//形参  拷贝构造
void func(Test t){
	
}

void bar(Test& t){
	
}

int main(){
	Test t1;
	Test t2(t1);//实例化一个对象t2   拷贝构造
	Test t3 = t1;//拷贝构造   
	Test t4 = getTest();//优化  没有拷贝构造
	cout <<"========="<<endl;
	func(t1);//拷贝构造
	bar(t1);//引用 不会调用拷贝构造
	cout <<"========="<<endl;
	t2 = t1;//两个对象都已经存在了，不存在拷贝构造
	cout << "---------" << endl;
	Test *pt = new Test(t1);
	cout << "---------" << endl;
	Test& rt = t1;//引用不会构造新的对象  不会调用拷贝构造函数
	cout << "---------" << endl;
	return 0;	
}

代码实现深拷贝

#include <iostream>
using namespace std;


class IntPoint{
private:
	int *p;//0xbf330000
public:
	IntPoint(int data):p(new int(data)){
		cout << "构造函数" << endl;	
	}
	//拷贝构造 深拷贝
	
	IntPoint(const IntPoint& op){
		cout << "拷贝构造" << endl;
		p = new int(*(op.p));
	}
	//两个对象都已存在了
	IntPoint& operator=(const IntPoint& op){
		if(this != &op){//避免自己给自己赋值时 先delete内存
			/*
			delete p;//先释放 后申请  释放成功 但是申请失败
			p = new int(*op.p);
			*/
			/*
			int *px = new int(*op.p);
			delete p;
			p = px;
			*/
			IntPoint tmp(op);//拷贝构造  tmp对象会被析构 delete
			swap(tmp.p,p);
			/*
			int *pt = tmp.p;
			tmp.p = p;
			p = pt;
			*/
		}
		return *this;
	}

	int getdata(){
		return *p;	
	}
	~IntPoint(){
		cout << "析构函数" << endl;
		if(p != NULL)
			delete p;
		p = NULL;
	}

};

int main(){
	IntPoint p1(10);
	IntPoint p2 = p1;// 变量赋值  拷贝构造
	cout << p1.getdata() << endl;
	cout << p2.getdata() << endl;

	p2 = p1;//拷贝赋值函数
	p2 = p2;
	

	return 0;	
}