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()。