C++共享类内指针时如何避免double free二次释放问题

要实现B对象指针的共享，同时避免重复释放，有以下几种成熟的处理方式：

方案1：使用标准库std::shared_ptr智能指针（最推荐） #

C++标准库提供的共享智能指针内部自带引用计数机制，会自动统计当前有多少个对象持有该指针，只有最后一个持有指针的对象销毁时，才会释放指向的内存，完全匹配你的需求。
修改后的代码如下：

#include<iostream>
#include<memory> // 引入智能指针头文件
using namespace std;

class B {};

class A {
public: 
    shared_ptr<B> b; // 替换裸指针为shared_ptr

    A() {
        cout << "ctor" << endl;
        b = make_shared<B>(); // 用make_shared分配内存
    }
    // 不需要手动写析构函数，shared_ptr会自动管理内存释放
};

void func(A a) {
    cout << a.b.get() << endl; // get()方法获取原始指针地址
}

int main() {
    A a;
    cout << a.b.get() << endl;
    func(a);
    cout << a.b.get() << endl;
}

这种方式不需要手动管理引用计数，也不需要自己写拷贝构造函数，标准库已经封装了所有安全逻辑，性能也经过优化，是首选方案。

方案2：禁止类A的拷贝，函数改为传引用 #

如果你不需要拷贝类A的对象，只是想把对象传入函数使用，可以直接禁用A的拷贝构造和拷贝赋值运算符，同时将func改为传引用，避免生成临时的A对象，从根源上避免多次析构的问题：

class A {
public: 
    B* b;

    A() {
        cout << "ctor" << endl;
        b = new B();
    }

    ~A() {
        cout << "dtor" << endl;
        delete b;
    }
    // 禁用拷贝构造和拷贝赋值
    A(const A&) = delete;
    A& operator=(const A&) = delete;
};

// 函数改为传引用，不会生成新的A对象
void func(A& a) {
    cout << a.b << endl;
}

这种方案没有额外的内存开销，性能最高，适合不需要共享A对象、只需要传递使用的场景。

方案3：手动实现引用计数 #

如果你有特殊需求不能使用标准库智能指针，可以自己实现引用计数逻辑：

1. 额外定义一个计数结构体，封装B对象和引用计数变量
2. 类A的拷贝构造函数中，将计数加1
3. 类A的析构函数中，将计数减1，只有计数为0时才释放内存
   这种方式需要自己处理所有边界情况，容易出现线程安全、计数异常等问题，非特殊情况不推荐使用。

内容的提问来源于stack exchange，提问作者Sourav Kannantha B