C++拷贝构造函数与浅拷贝，深拷贝

0.概述

1.默认拷贝构造函数

2.浅拷贝与深拷贝

3.拷贝构造函数调用的时机

0.概述                                                                                                                                                  

1.拷贝构造函数是当程序进行对对象复制的时候执行的构造函数。

2.拷贝构造函数也是构造函数的一种，因此当自己自行定义了一个拷贝构造函数后，一定要定义自己的构造函数，因为当没有拷贝构造函数的时候，编译器会自定义一个构造函数，但当有了拷贝构造函数后，编译器就不会自定义一个默认的构造函数，此时若不对构造函数进行定义，则在用户空间不能成功创建对象。

#include <iostream>
using namespace std;

class Text
{
	public:
	int a,b,c;
};

int main()
{
	Text t1;	//能够成功执行，即使没有写构造函数，编译器会生成一个默认的构造函数
	return 0;
}
----------------------------分割线 --------------------------------------- 
#include <iostream>
using namespace std;
class Text
{
	public:
	int a,b,c;
	Text(const Text& t)
	{
		
	} 
};

int main()
{
	Text t1;	//程序报错，因为有了复制构造函数后，编译器就不自动生成默认的构造函数，你必须自己写一个构造函数。
	return 0;
}

1.默认拷贝构造函数                                                                                                         

当我们没写拷贝构造函数而又对类对象进行了复制构造操作的时候，就会执行编译器默认的拷贝构造函数，这个复制构造函数很简单，只是用“老对象”的变量一一对“新对象“的变量复制，一般的形式：

CText(const Ctext& one)
{
    a = one.a;
    b = one.b;
    c = one.c;
}

当这样并不能完全解决对象复制的问题，下面详细说明

2.浅拷贝与深拷贝                                                                                                             

浅拷贝

所谓的浅拷贝就是在对象复制时，对对象的成员变量作简单的赋值。如默认拷贝构造函数。但出现动态成员时，浅拷贝就会出问题，下面给出例子：

下面的代码表示 t2 对象通过复制 t1对象而构造出来，先看代码

class Text
{
	public:
	Text()
	{
		p = new int(100);
	}
	~Text()
	{
		delete p;
	} 
	private:
	int *p;
	int a;
	int b;
};

int main()
{
	Text t1;
	t1.a=10;
	t1.b=20;
	Text t2=t1;
	return 0;
}

上面代码的 对象t1的a = t2的a，t1的b = t2的b，这并没问题，但t1的p也是=t2的p这才是浅拷贝的问题。看class Text应该是要每创建一个对象就为这个对象分配100个int型的内存空间，并用p指向他，而浅拷贝的简单赋值造成 t1的p = t2的p，即是 对象t1和t2的p都指向同一块内存了。这就是浅拷贝对动态成员的不足。这样的坏处就是当析构对象时，会对那段动态的内存空间析构（delete）两次。

深拷贝

深拷贝可以在有动态成员时，为新的对象new一块内存，再进行对象的复制，这样就不会使两个对象的指针指向同一块内存了。

class Text
{
	public:
	Text()
	{
		str = new string;
	}
	Text(Text& t)
	{
		str=new string;
		str = t.str;
		a = t.a;
		b = t.a;
	}
	~Text()
	{
		delete str;
	} 
	
	string *str;
	int a;
	int b;
};

int main()
{
	Text t1;
	*(t1.str) = "hello world";
	Text t2=t1;
	cout<<*(t2.str)<<endl;
	return 0;
}//打印结果：hello world

3.拷贝构造函数调用的时机                                                                                              

拷贝构造函数被调用的实际除了 Text t2 = t1，Text t2（t1）这样显示的调用以后，还有对象作为参数传入函数时都会调用拷贝构造函数

对象作为参数传入函数：

class Text
{
	public:
	Text()//构造函数
	{
		cout<<"create"<<endl;
	}
	Text(Text& t)//拷贝构造函数
	{
		cout<<"copy!"<<endl;
	}
	~Text()//析构函数
	{
		cout<<"delete"<<endl;
	}
	int a;
};

void fun(Text t)//注意，当Text t改成Text &t时，就不会调用拷贝构造函数，因为传入的是一个引用。引用不等于对象本身
{
	t.a=100;
}

int main()
{
	Text t;
	fun(t);
	return 0;
}//打印结果：create！copy！delete！delete！

上面代码：由于 void fun(Text  t)传入了对象，因此会在栈空间创建一个内存空间，用来复制传入的对象，因此调用了拷贝构造函数，打印copy，待fun函数结束了，才释放创建的内存空间，打印第一个delete，当整个main函数结束了，系统自动回收最先创建的对象，打印第二个delete