C++复制构造函数，一般在一下几种情况中出现

1：对象以值传递的方式传入函数时

2：对象以值传递的的方式从函数返回

3：一个对象通过另一个对象初始化

4：数组：根据数组中的初始化列表初始化数组的时候。

5：容器：初始化顺序容器中的元素

有3种情况必须使用复制构造函数：

A：如果有数据成员是指针

B：要在构造函数中分配其它资源

C：在创建对象是必须做一些另外的工作

对3进行一些解释：

如果一个类中的成员变量有引用数据类型，这时候就要特别注意了，比如在构造函数中是new出来的，那么在复制构造函数中最好还是要new。

下面是一个例子，如果在复制构造函数中不new一个数组，那么就要报错（自己写了释放str的析构函数），这个例子如果在自己写了析构函数来进行释放str的内存，或则想实现深层复制，给str重新分配空间，而不是把地址直接赋值给str，也是必须使用默认构造函数的例子。

#include <iostream>
#include <cstring>
#include "deep_copy.h"
using namespace std;
class DeepCopy{
private:
	int a;
	char *str;
public:
	DeepCopy(int aint,const char *str1):str(0)
	{
		a=aint;
		str=new char[50];
		strcpy(str,str1);
	}
	DeepCopy(const DeepCopy& dc):str(0)
	{

		a=dc.a;
		if(str==NULL)
			str=new char[50];
		strcpy(str,dc.str);
	}
	~DeepCopy()
	{
		cout<<"~deepcopy**********"<<endl;
		if(str!=NULL)
			delete str;
		str=NULL;
	}
	void set(const char* setStr)
	{
		strcpy(str,setStr);
	}
	void show()
	{
		cout<<"a="<<a<<"\nstr="<<str<<endl;
	}
};
int main()
{
	DeepCopy dp(10,"i love you ~~~~~~~");
	dp.show();
	DeepCopy dp1=dp;
	dp1.show();
	cout<<"modify the dp1,check if the dp will change!!! "<<endl;
	dp1.set("i hate you!!!");
	dp.show();
	dp1.show();
}

一下是下面的关于c++深层拷贝的一些问题，我始终觉得有点问题

出处：http://www.cnblogs.com/BlueTzar/articles/1223313.html

对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a;
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。

#include  < iostream >
using   namespace  std;

class  CExample  {
private:
    　int a;
public:
    　CExample(int b)
    　{ a=b;}
    　void Show ()
    　{
        cout<<a<<endl;
    }
} ;

int  main()
{
    　CExample A(100);
    　CExample B=A;
    　B.Show ();
    　return 0;
}  

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

#include  < iostream >
using   namespace  std;

class  CExample  {
private:
    int a;
public:
    CExample(int b)
    { a=b;}
    
    CExample(const CExample& C)
    {
        a=C.a;
    }
    void Show ()
    {
        cout<<a<<endl;
    }
} ;

int  main()
{
    CExample A(100);
    CExample B=A;
    B.Show ();
    return 0;
}  

CExample(constCExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数返回
一个对象需要通过另外一个对象进行初始化。

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝

　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

        Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。