下面举一个简单的例子说明对象之间的拷贝（此例中没有自定义拷贝构造函数，在调用拷贝构造函数的时候，编译器会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝）浅拷贝：
#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;
}
输出结果：
100
当一个已经初始化的自定义类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。一下情况都会调用拷贝构造函数：
- 一个对象以值传递的方式传入函数体
- 一个对象以值传递的方式从函数返回
- 一个对象需要通过另一个对象进行初始化
浅拷贝和深拷贝详解
在某些情况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是说把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那么A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（析构），这时A内存就成了野指针，出现运行错误。
两种拷贝方式可以简单的理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个重新分配的的过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
下面举例说明深拷贝：
#include<iostream>
using namespace std;
class CA
{
private:
int a;
char* str;
public:
CA(int b,char* cstr)
{
a=b;
str=new char[b];
strcpy(str,cstr);
}
CA(const CA& C)
{
a=b;
str=new char[a];
if(str!=0)
strcpy(str,C.str);
}
void Show()
{
cout<<str<<endl;
}
~CA()
{
delete str;
str=0;
}
};
void main()
{
CA A(10,"hello");
CA B=A;
B.Show();
return 0;
}
输出结果：
hello
上面的示例可以看出，首先初始化一个CA对象之后，在进行自定义拷贝构造函数把A中的变量str拷贝给对象B，在此之中，A可能会调用析构函数delete str操作，使得str变量的地址回收，如果在自定义拷贝构造函数中进行深拷贝操作，对象A析构释放资源后可能导致资源归属不清的情况而导致程序运行错误。深拷贝会在拷贝的时候重新给str分配内存单元，这样就可以在不出错的情况下独立操作B中的变量。
来源：https://www.cnblogs.com/DannyShi/p/4584711.html