深拷贝与浅拷贝~动态内存释放有关

浅拷贝就是对象的数据成员之间的简单赋值，如你设计了一个没有类而没有提供它的复制构造函数，当用该类的一个对象去给令一个对象赋值时所执行的过程就是浅拷贝，如：

class A
 { public: A(int _data) :
data(_data){} A(){}
private: int data; 
};
int main() 
{ A a(5), b = a; // 仅仅是数据成员之间的赋值 }

这一句b = a;就是浅拷贝，执行完这句后b.data = 5;
如果对象中没有其他的资源（如：堆，文件，系统资源等），则深拷贝和浅拷贝没有什么区别，

但当对象中有这些资源时，例子：

class A 
{ public: A(int _size) : size(_size)
{data = new int[size];
} // 假如其中有一段动态分配的内存
 A(){};
 ~A()
{delete [] data;
} // 析构时释放资源
private: int* data; 
int size; 
}
int main() 
{ A a(5),
 b = a; // 注意这一句 }

这里的b = a会造成未定义行为，因为类A中的复制构造函数是编译器生成的，所以b = a执行的是一个浅拷贝过程。我说过浅拷贝是对象数据之间的简单赋值，比如：
b.size = a.size; b.data = a.data; // Oops!
这里b的指针data和a的指针指向了堆上的同一块内存，a和b析构时，b先把其data指向的动态分配的内存释放了一次，而后a析构时又将这块已经被释放过的内存再释放一次。
对同一块动态内存执行2次以上释放的结果是未定义的，所以这将导致内存泄露或程序崩溃。

所以这里就需要深拷贝来解决这个问题，

深拷贝指的就是当拷贝对象中有对其他资源（如堆、文件、系统等）的引用时（引用可以是指针或引用）时，

对象的另开辟一块新的资源，而不再对拷贝对象中有对其他资源的引用的指针或引用进行单纯的赋值。

如：

class A 
{ 
public: A(int _size) : size(_size)
{data = new int[size];} 
// 假如其中有一段动态分配的内存
 A(){};
 A(const A& _A) : size(_A.size)
{data = new int[size];} 
// 深拷贝 
~A(){delete [] data;}
 // 析构时释放资源
private: int* data; int size;
 }
int main()
 { A a(5), b = a; // 这次就没问题了 }

总结：

深拷贝和浅拷贝的区别是在对象状态中包含其它对象的引用的时候，当拷贝一个对象时，如果需要拷贝这个对象引用的对象，则是深拷贝，否则是浅拷贝。

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

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