构造函数是一个初始化类对象的函数，即使不显示调用，编译器也会隐式调用构造函数初始化类对象。同样的，拷贝构造函数是一种特殊的构造函数，目的也是初始化类对象，同样在不声明的情况下也会隐式调用该函数。而隐式调用拷贝构造函数的时候，我们称之为“浅拷贝”。但是，请注意一点，并不是说显示调用就是“深拷贝”，而是如果要深拷贝一定要显示调用。
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数常用于：
- 通过使用另一个同类型的对象来初始化新创建的对象；
- 复制对象把它作为参数传递给函数；
- 复制对象，并从函数返回这个对象。
如下：
#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;
}
我们可以很清楚看到在用对象a给对象b赋值的时候调用了拷贝构造函数。
那么复制对象，并从函数返回这个对象。是怎样调用拷贝构造函数的？
我们在调用g_fun()时，会产生以下几个重要步骤：
(1).A对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
(2).然后调用拷贝构造函数把A的值给C。 整个这两个步骤有点像：CExample C(A);
(3).等g_fun()执行完后, 析构掉 C 对象。
对，就这样调用的。
函数的返回值是类的对象时
CExample g_fun()
{
CExample temp(0);
return temp;
}
int main()
{
g_fun();
return 0;
}
当g_Fun()函数执行到return时，会产生以下几个重要步骤：
(1). 先会产生一个临时变量，就叫q吧。
(2). 然后调用拷贝构造函数把temp的值给q。整个这两个步骤有点像：CExample q(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_fun()执行完后再析构掉q对象。
浅拷贝
浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：
#include<iostream>
using namespace std;
class Rect
{
public:
Rect()
{
p=new int(100);
}
~Rect()
{
assert(p!=NULL);
delete p;
}
private:
int width;
int height;
int *p;
};
int main()
{
Rect rect1;
Rect rect2(rect1);
return 0;
}在这段代码运行结束之前，会出现一个运行错误。原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。我们来分析一下：
在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，因此执行后的内存情况大致如下：
在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，如下图所示：
当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。
深拷贝
在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：
#include<iostream>
#include<assert.h>
using namespace std;
class Rect
{
public:
Rect()
{
p=new int(100);
}
Rect(const Rect& r)
{
width=r.width;
height=r.height;
p=new int(100);
*p=*(r.p);
}
~Rect()
{
assert(p!=NULL);
delete p;
}
private:
int width;
int height;
int *p;
};
int main()
{
Rect rect1;
Rect rect2(rect1);
return 0;
}此时，在完成对象的复制后，内存的一个大致情况如下：
此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。
那么如何防止默认拷贝发生？？？
通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b)
{
a = b;
cout<<"creat: "<<a<<endl;
}
private:
//拷贝构造函数，只是声明
CExample(const CExample& C);
public:
~CExample()
{
cout<< "delete: "<<a<<endl;
}
void Show ()
{
cout<<a<<endl;
}
};
void g_Fun(CExample C)
{
cout<<"test"<<endl;
}
int main()
{
CExample test(1);
//g_Fun(test); //按值传递将出错
return 0;
}为什么要用const引用？
const 更多是给程序员的一个限制， 告诉程序员这个变量是只读的。因此为了安全， 一般建议所有的只读变量加const限制以防止程序员犯错。因为复制构造函数是用引用方式传递复制对象，引用方式传递的是地址，因此在构造函数内对该引用的修改会影响源对象。而你在用对象a1构造a2时，自然不希望复制构造函数会改变a1的内容，因此要防止复制构造函数内部修改该引用，所以用const声明。
为什么拷贝构造函数要传引用？？
上面 B(A) 中实参 A 赋给形参 C（CExample(const CExample C)） 的时候，也需要拷贝构造函数 C(A) ，这个 C(A) 中的 A 又要赋给形参 C'.......这是不是要无限次的进行拷贝？所以，如果使用引用就可以避免这样的无限循环。
