浅拷贝与深拷贝

　　如果一个类拥有资源（堆，即分配的动态内存），当这个类的对象发生复制时复制了资源的过程就叫深拷贝，而存在资源(堆，即分配的动态内存)但并未复制资源的情况叫浅拷贝。编译器会为类提供一个默认拷贝构造函数就是一个浅拷贝。

　　浅拷贝存在的问题：类体内的成员需要开辟动态内存来存放资源，复制时如果用浅拷贝只会拷贝指向动态内存的指针，并未实际重新分配一块内存来存放资源，在对象虚构时，会出现两次释放同一块内存，导致运行错误。

　　浅拷贝：

 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 class Test
 5 {
 6 public:
 7     Test(const char* name, int a)    {
 8         m_a = a;
 9         m_pName = new char[strlen(name) + 1];
10         strcpy(m_pName, name);
11     }
12 
13     virtual ~Test()
14     {
15         if (m_pName)
16         {
17             delete [] m_pName;
18             m_pName = NULL;
19         }
20         std::cout<<"Test::~Test()"<<std::endl;
21     }
22 
23     void Print()
24     {
25         std::cout<<m_pName<<m_a<<std::endl;
26     }
27 protected:
28 private:
29     int        m_a;
30     char*    m_pName;
31 };
32 
33 int _tmain(int argc, _TCHAR* argv[])
34 {
35     Test _t("测试。。。。。。", 10000);
36     Test _b = _t;
37     _b.Print();
38 
39     return 0;
40 }

　　深拷贝：

 1 #include "stdafx.h"
 2 #include <iostream>
 3 
 4 class Test
 5 {
 6 public:
 7     Test(const char* name, int a)    {
 8         m_a = a;
 9         m_pName = new char[strlen(name) + 1];
10         strcpy(m_pName, name);
11     }
12 
13     virtual ~Test()
14     {
15         if (m_pName)
16         {
17             delete [] m_pName;
18             m_pName = NULL;
19         }
20         std::cout<<"Test::~Test()"<<std::endl;
21     }
22     
23     // 重载拷贝构造函数
24     Test(const Test& _t)
25     {
26         m_a = _t.m_a;
27         m_pName = new char[strlen(_t.m_pName) + 1];
28         strcpy(m_pName, _t.m_pName);
29     }
30 
31     void Print()
32     {
33         std::cout<<m_pName<<m_a<<std::endl;
34     }
35 protected:
36 public:
37     int        m_a;
38     char*    m_pName;
39 };
40 
41 int _tmain(int argc, _TCHAR* argv[])
42 {
43     Test _t("测试。。。。。。", 10000);
44     Test _b = _t;
45     _b.Print();
46 
47     return 0;
48 }