浅拷贝与深拷贝

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

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

　　浅拷贝：

#include "stdafx.h"
#include <iostream>

class Test
{
public:
    Test(const char* name, int a)    {
        m_a = a;
        m_pName = new char[strlen(name) + 1];
        strcpy(m_pName, name);
    }

    virtual ~Test()
    {
        if (m_pName)
        {
            delete [] m_pName;
            m_pName = NULL;
        }
        std::cout<<"Test::~Test()"<<std::endl;
    }

    void Print()
    {
        std::cout<<m_pName<<m_a<<std::endl;
    }
protected:
private:
    int        m_a;
    char*    m_pName;
};

int _tmain(int argc, _TCHAR* argv[])
{
    Test _t("测试。。。。。。", 10000);
    Test _b = _t;
    _b.Print();

    return 0;
}

　　深拷贝：

#include "stdafx.h"
#include <iostream>

class Test
{
public:
    Test(const char* name, int a)    {
        m_a = a;
        m_pName = new char[strlen(name) + 1];
        strcpy(m_pName, name);
    }

    virtual ~Test()
    {
        if (m_pName)
        {
            delete [] m_pName;
            m_pName = NULL;
        }
        std::cout<<"Test::~Test()"<<std::endl;
    }
    
    // 重载拷贝构造函数
    Test(const Test& _t)
    {
        m_a = _t.m_a;
        m_pName = new char[strlen(_t.m_pName) + 1];
        strcpy(m_pName, _t.m_pName);
    }

    void Print()
    {
        std::cout<<m_pName<<m_a<<std::endl;
    }
protected:
public:
    int        m_a;
    char*    m_pName;
};

int _tmain(int argc, _TCHAR* argv[])
{
    Test _t("测试。。。。。。", 10000);
    Test _b = _t;
    _b.Print();

    return 0;
}