C++中的深拷贝(Deep Copy) 和 浅拷贝(Shallow Copy)

本质：  深浅拷贝只在 “资源”场景下才有意义，即 处理 对象内 有指针(或者资源句柄)。

一个类中  默认生成的  拷贝构造函数 和 拷贝赋值函数，都是浅拷贝。   一旦类的定义中出现了指针， 指针会指向堆内存空间。  

容易出现下面的问题:

        多次释放

        悬空指针

        修改会相互影响

具体示例：

#include <iostream>
using namespace std;

class MyData{
public:
    int* ptr;
    
    MyData(int value){
        ptr = new int(value);
    }
    
    // 默认生成拷贝构造 拷贝赋值
    // MyData(const MyData&) = default; // 默认浅拷贝
    // MyData& operator=(const MyData&) = default;// 默认拷贝赋值

    ~MyData(){
        delete ptr;
    }
    

}；

1.多次释放：

        int main(){

                MyData a(10);

                MyData b=a; // 浅拷贝

                return 0;

        }

main 结束时，a 和 b 都会调用析构函数，分别delete ptr,重复释放。

2.悬空指针

        int main(){

                MyData a(10);

                MyDate b=a;

                delete a.ptr;

                cout<<*b.ptr<<endl;

        }

b.ptr指向的内存已经被a释放，a依然去访问它，悬空指针。

3.被另一个对象更改

        int main(){

                MyData a(10);

                MyData b = a;

                *a.ptr = 66;

                cout<<*b.ptr<<endl;

        }

  b所指向的指针对象被意外更改。

解决方法：

最佳的处理方法是：  用  智能指针   +  深拷贝  实现

        不用自己管理 new /delete,避免所有问题, 会解决上面的

#include <memory>

class MyData{
    private:
        std::unique_ptr<int>  data;
    public:
        MyData(int x):data(std::make_unique<int>(x)){}
        //深拷贝构造
        MyData(const MyData& other):data(std::make_unique<int>(*other.data)){}
        //深拷贝赋值运算
        //为什么拷贝赋值运算符要return *this?
        // 因为赋值运算符通常返回对当前对象的引用，以允许链式赋值操作
        MyData& operator=(const MyData& other){
            if(this != &other){
                data = std::make_unique<int>(*other.data);
            }
            return * this;
        }
        //默认移动(零开销)
        MyData(MyData&& ) noexcept = default;
        MyData& operator=(MyData&&) noexcep = default;

};

使用的情况：

        MyData a(10) ;

        MyData b = std::move(a);

        MyData c = a;

如果没有显示声明MyData(MyData&&),移动构造被抑制，编译器会退而使用 拷贝构造函数。