拷贝构造函数与深拷贝和浅拷贝

拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。作用就是用来复制对象，在使用这个对象的实例来初始化这个对象的一个新的实例。类中可以存在多个拷贝构造函数。

拷贝构造函数的调用时机

当函数的参数为类的对象时

#include<iostream>
using namespace std;
class CExample
{
private:int a;
public:CExample(int b){a=b;printf("constructor is called\n");}CExample(const CExample & c){a=c.a;printf("copy constructor is called\n");}~CExample(){cout<<"destructor is called\n";}void Show(){cout<<a<<endl;}
};
void g_fun(CExample c)
{cout<<"g_func"<<endl;
}
int main()
{CExample A(100);CExample B=A;B.Show(); g_fun(A);return 0;
}

调用g_fun()时，会产生以下几个重要步骤：
(1).A对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
(2).然后调用拷贝构造函数把A的值给C。整个这两个步骤有点像：CExample C(A);
(3).等g_fun()执行完后, 析构掉 C 对象。

函数的返回值是类的对象

#include<iostream>
using namespace std;
class CExample
{
private:int a;
public://构造函数CExample(int b){a=b;printf("constructor is called\n");}//拷贝构造函数CExample(const CExample & c){a=c.a;printf("copy constructor is called\n");}//析构函数~CExample(){cout<<"destructor is called\n";}void Show(){cout<<a<<endl;}
};
CExample g_fun()
{CExample temp(0);return temp;
}
int main()
{g_fun();return 0;
}

当g_Fun()函数执行到return时，会产生以下几个重要步骤：
(1). 先会产生一个临时变量，就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像：CExample XXXX(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_fun()执行完后再析构掉XXXX对象。

对象需要通过另外一个对象进行初始化

CExample A(100);
CExample B=A;

浅拷贝与深拷贝

拷贝者和被拷贝者若是同一个地址，则为浅拷贝，反之为深拷贝，深拷贝会在堆内存中另外申请空间来储存数据。默认的拷贝构造函数实现的是浅拷贝，数据成员中有指针时，必须要用深拷贝。

一般的赋值操作是深度拷贝：

//深度拷贝
int a = 5;
int b = a;

简单的指针指向，则是浅拷贝：

//浅拷贝
int a = 8;
int *p;
p = &a;char* str1 = "HelloWorld";
char* str2 = str1;

如果要将上面的浅拷贝转换为深拷贝，需要这样

//深度拷贝
int a = 8;
int *p = new int;
*p = a;char* str1 = "HelloWorld";
int len = strlen(str1);
char *str2 = new char[len];
memcpy(str2, str1, len);

以字符串拷贝为例，浅拷贝后，str1和str2同指向0x123456，不管哪一个指针，对该空间内容的修改都会影响另一个指针。

深拷贝后，str1和str2指向不同的内存空间，各自的空间的内容一样。因为空间不同，所以不管哪一个指针，对该空间内容的修改都不会影响另一个指针。

当出现类的等号赋值时，会调用拷贝函数，在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。这时，必须采用深拷贝。

默认的拷贝构造函数存在弊端，看如下类定义

class TestCls{
public:int a;int *p;public:TestCls()   //无参构造函数{std::cout<<"TestCls()"<<std::endl;p = new int;}~TestCls()     //析构函数{delete p;   std::cout<<"~TestCls()"<<std::endl;}
};int main(void)
{TestCls t1;TestCls t2 = t1;   //效果等同于TestCls t2(t1);return 0;
}

类的默认拷贝构造函数只会用被拷贝类的成员的值为拷贝类简单初始化，也就是说二者的p指针指向的内存空间是一致的。以前面TestCls可以知道，编译器为我们默认定义的拷贝构造函数为：

TestCls(const TestCls& testCls)
{a = testCls.a;p = testCls.p;      //两个类的p指针指向的地址一致。
}

main函数将要退出时，拷贝类t2的析构函数先得到执行，它把自身p指向的堆空间释放了；接下来，t1的析构函数得到调用，被拷贝类t1的析构函数得到调用，它同样要去析构自身的p指向指向的堆空间，但是该空间和t2类中p指向的空间一样，造成重复释放，程序运行崩溃。

解决办法十分简单，自定义拷贝构造函数，里面用深度拷贝的方式为拷贝类初始化：

class TestCls{
public:int a;int *p;public:TestCls(){std::cout<<"TestCls()"<<std::endl;p = new int;}TestCls(const TestCls& testCls){std::cout<<"TestCls(const TestCls& testCls)"<<std::endl;a = testCls.a;//p = testCls.p;p = new int;*p = *(testCls.p);      //为拷贝类的p指针分配空间，实现深度拷贝}~TestCls(){delete p;   std::cout<<"~TestCls()"<<std::endl;}
};int main(void)
{TestCls t1;TestCls t2 = t1;return 0;
}

防止默认拷贝发生

自定义拷贝构造函数，并设置为private属性，其实现体可以什么都不写，那么这个类将变成一个不可被复制的类了。