shared_ptr 的内存泄漏

#include <bits/stdc++.h>
#include <memory>

using namespace std;

class B;

class A {
public:
    A() {
        std::cout << "A()" << std::endl;
    }

    ~A() {
        std::cout << "~A()" << std::endl;
    }

public:
    shared_ptr<B> spa;
};

class B {
public:
    B() {
        std::cout << "B()" << std::endl;
    }

    ~B() {
        std::cout << "~B()" << std::endl;
    }

public:
    shared_ptr<A> spb;
};

int main() {
    shared_ptr<A> pa(new A());
    shared_ptr<B> pb(new B());
    pa->spa = pb;
    cout << pb.use_count() << " " << pa->spa.use_count() << endl;
    pb->spb = pa;
    cout << pa.use_count() << " " << pb->spb.use_count() << endl;
    return 0;
}

直接运行代码，会发现 上面输出的 都是 2。

程序中的对象是按逆序进行销毁的。

所以，一开始会先销毁 pb，使得 spa 和 pb 的对象引用计数减 1；然后销毁 pa，使得 spb 和 pa 的对象引用计数减 1。最终，在动态内存中的对象并不会销毁。所以会发现，上面代码并没有调用两个类的析构函数。

解决方案：把其中一个类中的 shared_ptr 改为 weak_ptr。

把类 A 中的 shared_ptr 改为 weak_ptr

会发现输出为：

1 1
2 2
~B()
~A()

同样，程序先销毁 pb。pb 的对象引用计数为 1，然后销毁时减 1，所以会调用 B 的析构函数，也就是 ~B()；而在调用 ~B() 后的隐式析构阶段，会销毁 B 的成员 (也就是 spb)，使得 spb 的对象引用计数减 1；最终销毁 pa，引用计数再减 1，变成 0，随即调用 A 的析构函数，即输出 ~A()

把类 B 中的 shared_ptr 改为 weak_ptr

会发现输出为：

2 2
1 1
~A()
~B()

过程几乎和上面一样。先销毁 pb，使得 pb 的对象的引用计数减 1，变为 1；然后销毁 pa，pa 的对象的引用计数本身就为 1，所以会调用 A 的析构函数，即输出 ~A()；因为调用了 ~A()，所以会销毁 A 的成员 spa，使得 spa 的对象的引用计数为 0，调用 B 的析构函数，输出 ~B()。