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

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

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

容易出现下面的问题:

多次释放

悬空指针

修改会相互影响

具体示例：

cpp 复制代码

#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,避免所有问题, 会解决上面的

cpp 复制代码

#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&&),移动构造被抑制，编译器会退而使用拷贝构造函数。

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

容易出现下面的问题:

解决方法：

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