C++ 中的深拷贝与浅拷贝

　　浅拷贝：又称值拷贝，将源对象的值拷贝到目标对象中去，本质上来说源对象和目标对象共用一份实体，只是所引用的变量名不同，地址其实还是相同的。举个简单的例子，你的小名叫西西，大名叫冬冬，当别人叫你西西或者冬冬的时候你都会答应，这两个名字虽然不相同，但是都指的是你。

　　假设有一个String类，String s1;String s2(s1);在进行拷贝构造的时候将对象s1里的值全部拷贝到对象s2里。

　　我们现在来简单的实现一下这个类

#include <iostream>
#include<cstring>

using namespace std;

class STRING 
{
public:
    STRING( const char* s = "" ) :_str( new char[strlen(s)+1] )

    {
        strcpy_s( _str, strlen(s)+1, s );
    }
    STRING( const STRING& s )
    {
        _str = s._str;
    }
    STRING& operator=(const STRING& s)
    {
        if (this != &s)
        {
            this->_str = s._str;
        }
        return *this;
    }

    ~STRING()
    {
        cout << "~STRING" << endl;
        if (_str)
        {
            delete[] _str;
            _str = NULL;
        }
    }

    void show()
    {
        cout << _str << endl;
    }
private:
    char* _str;
};

int main()
{
    STRING s1("hello linux");
    STRING s2(s1);
    s2.show();

    return 0;
}

其实这个程序是存在问题的，什么问题呢？我们想一下，创建s2的时候程序必然会去调用拷贝构造函数，这时候拷贝构造仅仅只是完成了值拷贝，导致两个指针指向了同一块内存区域。随着程序的运行结束，又去调用析构函数，先是s2去调用析构函数，释放了它指向的内存区域，接着s1又去调用析构函数，这时候析构函数企图释放一块已经被释放的内存区域，程序将会崩溃。s1和s2的关系就是这样的：

进行调试程序发现s1和s2确实指向了同一块区域:

所以程序会崩溃是应该的，那么这个问题应该怎么去解决呢？这就引出了深拷贝。

深拷贝，拷贝的时候先开辟出和源对象大小一样的空间，然后将源对象里的内容拷贝到目标对象中去，这样两个指针就指向了不同的内存位置。并且里面的内容是一样的，这样不但达到了我们想要的目的，还不会出现问题，两个指针先后去调用析构函数，分别释放自己所指向的位置。即为每次增加一个指针，便申请一块新的内存，并让这个指针指向新的内存，深拷贝情况下，不会出现重复释放同一块内存的错误。

深拷贝实际上是这样的：

深拷贝的拷贝构造函数和赋值运算符的重载传统实现：

STRING( const STRING& s )
    {
        //_str = s._str;
        _str = new char[strlen(s._str) + 1];
        strcpy_s( _str, strlen(s._str) + 1, s._str );
    }
    STRING& operator=(const STRING& s)
    {
        if (this != &s)
        {
            //this->_str = s._str;
            delete[] _str;
            this->_str = new char[strlen(s._str) + 1];
            strcpy_s(this->_str, strlen(s._str) + 1, s._str);
        }
        return *this;
    }

这里的拷贝构造函数我们很容易理解，先开辟出和源对象一样大的内存区域，然后将需要拷贝的数据复制到目标拷贝对象，

那么这里的赋值运算符的重载是怎么样做的呢？

这种方法解决了我们的指针悬挂问题，通过不断的开空间让不同的指针指向不同的内存，以防止同一块内存被释放两次的问题，还有一种深拷贝的现代写法：

STRING( const STRING& s ):_str(NULL)
    {
        STRING tmp(s._str);// 调用了构造函数，完成了空间的开辟以及值的拷贝
        swap(this->_str, tmp._str); //交换tmp和目标拷贝对象所指向的内容
    }

    STRING& operator=(const STRING& s)
    {
        if ( this != &s )//不让自己给自己赋值
        {
            STRING tmp(s._str);//调用构造函数完成空间的开辟以及赋值工作
            swap(this->_str, tmp._str);//交换tmp和目标拷贝对象所指向的内容
        }
        return *this;
    }

先来分析一下拷贝构造是怎么实现的：

拷贝构造调用完成之后，会接着去调用析构函数来销毁局部对象tmp，按照这种思路，不难可以想到s2的值一定和拷贝构造里的tmp的值一样，指向同一块内存区域，通过调试可以看出来：

在拷贝构造函数里的tmp：

调用完拷贝构造后的s2：（此时tmp被析构）

可以看到s2的地址值和拷贝构造里的tmp的地址值是一样

关于赋值运算符的重载还可以这样来写：

STRING& operator=(STRING s)
{
　　swap(_str, s._str);
　　return *this;
}

#include <iostream>
#include<cstring>

using namespace std;

class STRING 
{
public:
    STRING( const char* s = "" ) :_str( new char[strlen(s)+1] )

    {
        strcpy_s( _str, strlen(s)+1, s );
    }
    //STRING( const STRING& s )
    //{
    //    //_str = s._str; //浅拷贝的写法
    //    cout << "拷贝构造函数" << endl;
    //    _str = new char[strlen(s._str) + 1];
    //    strcpy_s( _str, strlen(s._str) + 1, s._str );
    //}
    //STRING& operator=(const STRING& s)
    //{
    //    cout << "运算符重载" << endl;
    //    if (this != &s)
    //    {
    //        //this->_str = s._str; //浅拷贝的写法
    //        delete[] _str;
    //        this->_str = new char[strlen(s._str) + 1];
    //        strcpy_s(this->_str, strlen(s._str) + 1, s._str);
    //    }
    //    return *this;
    //}

    STRING( const STRING& s ):_str(NULL)
    {
        STRING tmp(s._str);// 调用了构造函数，完成了空间的开辟以及值的拷贝
        swap(this->_str, tmp._str); //交换tmp和目标拷贝对象所指向的内容
    }

    STRING& operator=(const STRING& s)
    {
        if ( this != &s )//不让自己给自己赋值
        {
            STRING tmp(s._str);//调用构造函数完成空间的开辟以及赋值工作
            swap(this->_str, tmp._str);//交换tmp和目标拷贝对象所指向的内容
        }
        return *this;
    }

    ~STRING()
    {
        cout << "~STRING" << endl;
        if (_str)
        {
            delete[] _str;
            _str = NULL;
        }
    }

    void show()
    {
        cout << _str << endl;
    }
private:
    char* _str;
};

int main()
{
    //STRING s1("hello linux");
    //STRING s2(s1);
    //STRING s2 = s1;
    //s2.show();
    const char* str = "hello linux!";
    STRING  s1(str);
    STRING s2;
    s2 = s1;
    s1.show();
    s2.show();

    return 0;
}

参考与

浅析C++中的深浅拷贝 - qq_39344902的博客 - CSDN博客
https://blog.csdn.net/qq_39344902/article/details/79798297