深拷贝与浅拷贝的深入剖析

浅拷贝，即在定义一个类A，使用类似A obj;  A obj1(obj);或者A obj1 = obj; 时候，由于没有自定义拷贝构造函数，C++编译器自动会产生一个默认的拷贝构造函数。如果类中含有指针变量，默认的拷贝构造函数必定出错。

用简单的话来说就是浅拷贝，只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

其一，浅拷贝只是拷贝了指针，使得两个指针指向同一个地址，这样在对象块结束，调用函数析构的时，会造成同一份资源析构2次，即delete同一块内存2次，造成程序崩溃。

其二，浅拷贝使得obj.m_data和obj1.m_data指向同一块内存，任何一方的变动都会影响到另一方。

其三，在释放内存的时候，会造成obj1.m_data原有的内存没有被释放。当delete obj.m_data, obj.m_data内存被释放后，由于之前obj.m_data和obj1.m_data指向的是同一个内存空间，obj1.m_data所指的空间不能在被利用了，delete obj1.m_data也不会成功，一致已经无法操作该空间，所以导致内存泄露。

深拷贝采用了在堆内存中申请新的空间来存储数据，这样每个可以避免指针悬挂。

浅拷贝导致错误程序示例

#include <iostream>
#include <string.h>
 
using namespace std;
 
class Name
{
public:
    Name(const char *p)
    {
        m_len = strlen(p);
        m_p = (char *)malloc(m_len + 1);
    }
 
    ~Name()
    {
        cout << "析构函数被调用" << endl;
        if (m_p != NULL)
        {
            free (m_p);
            m_p = NULL;
            m_len = 0;
        }
        cout << "析构函数执行结束" << endl;
    }
private:
    char *m_p;
    int m_len;
};
 
int main()
{
    {
        Name name1("xiaoming");
        Name name2 = name1;
    }
 
    return 0;
}

深拷贝正确编写示例

#include <iostream>
#include <string.h>
 
using namespace std;
 
class Name
{
public:
    Name(const char *p)
    {
        m_len = strlen(p);
        m_p = (char *)malloc(m_len + 1);
    }
 
    // 解决浅拷贝的方案：手动编写拷贝构造函数，进行深拷贝
    Name (const Name &obj)
    {
        m_len = obj.m_len;
        m_p = (char *)malloc(m_len + 1);
        strcpy (m_p, obj.m_p);
    }
 
    ~Name()
    {
        cout << "析构函数被调用" << endl;
        if (m_p != NULL)
        {
            free (m_p);
            m_p = NULL;
            m_len = 0;
        }
        cout << "析构函数执行结束" << endl;
    }
private:
    char *m_p;
    int m_len;
};
 
int main()
{
    {
        Name name1("xiaoming");
        Name name2 = name1;
    }
 
    return 0;
}

深拷贝:在拷贝构造函数中为成员变量申请了新的内存空间，这就使得两个对象的成员变量不指向同一个内存空间，除非你的确需要这样做，用于实现一些其他的用途。

浅拷贝：也就是在对象复制时，只是对对象中的数据成员进行简单的赋值，如果对象中存在动态成员，即指针，浅拷贝就会出现问题。