shared_ptr智能指針為什么循環引用會出問題

　　學習C++的shared_ptr智能指針你可能會碰到一個問題，循環引用為什么會出現問題？為什么不能釋放？C++不是保證了對象構造成功退出作用域時就絕對會調用析構函數嗎，調用析構函數不也會調用成員變量和父類的析構函數嗎，為什么還不能釋放呢？難道是編譯器有bug?

　　非也，原因是一句繞口令式的答案：你以為的不是你以為的。

　　為什么？先看看下面的循環引用代碼示例：

#include <iostream>
#include <typeinfo>

using namespace std;

template <typename T>
class SharedPointer {
private:
    class Implement    {
    public:
        Implement(T* p) : mPointer(p), mRefs(1) {
            cout << "Implement()" << endl;
        }

        ~Implement(){
            delete mPointer;
            cout << "~Implement()" << endl;
        }

        T* mPointer;
        size_t mRefs;
    };

    Implement* mImplPtr;

public:
    explicit SharedPointer(T* p = nullptr)
        : mImplPtr(new Implement(p)) {
        cout << "SharedPointer<" << typeid(T).name() << ">(" << this << ")" << endl;
    }

    ~SharedPointer() {
        cout << "~SharedPointer<" << typeid(T).name() << ">(" << this << ")" << endl;
        decrease();
    }

    SharedPointer(const SharedPointer& other)
        : mImplPtr(other.mImplPtr) {
        increase();
        cout << "SharedPointer<" << typeid(T).name() << ">(other=" << &other << ")" << endl;
    }

    SharedPointer& operator = (const SharedPointer& other) {
        if(mImplPtr != other.mImplPtr) {
            decrease();
            mImplPtr = other.mImplPtr;
            increase();
        }

        return *this;
    }

    T* operator -> () const    {
        return mImplPtr->mPointer;
    }

    T& operator * () const {
        return *(mImplPtr->mPointer);
    }

private:
    void decrease()    {
        if(--(mImplPtr->mRefs) == 0) {
            delete mImplPtr;
        }
    }

    void increase()    {
        ++(mImplPtr->mRefs);
    }
};

class B;

class A {
public:
    SharedPointer<B> m_ptr;
};

class B {
public:
    SharedPointer<A> m_ptr;
};

int main() {
    SharedPointer<A> a(new A);
    SharedPointer<B> b(new B);
    a->m_ptr = b;
    b->m_ptr = a;

    return 0;
}

　　運行代碼，你會得到下方的結果（內存地址可能不同）：

Implement()
SharedPointer<1B>(0x417eb0)
Implement()
SharedPointer<1A>(0x7fff4fd10230)
Implement()
SharedPointer<1A>(0x418f20)
Implement()
SharedPointer<1B>(0x7fff4fd10218)
~Implement()
~Implement()
~SharedPointer<1B>(0x7fff4fd10218)
~SharedPointer<1A>(0x7fff4fd10230)

 

　　為什么申請的兩個堆空間沒有被釋放？？

　　原因是析構智能指針對象時所調用的析構函數發現引用計數仍然不為0，故而不能釋放。

　　為什么引用計數仍然不為0，因為我們的循環引用導致了引用計數額外各增加了1，而析構函數並不知情，也無法知情，所以無法修正，也不應該去修正，因為這不是析構函數該干的活。

 

　　那我們反過來推理，如果要釋放兩個堆空間如何操作？

　　要釋放兩個棧空間就必須保證智能指針對象析構時一並釋放它們，也就是引用計數最終為0，然而要讓引用計數最終為0就需要兩個堆空間的成員變量m_ptr智能指針先析構，但是堆空間的成員變量只能在堆空間析構時才能析構，這就進入雞生蛋蛋生雞的問題了。。。所以誰也不能先析構。

 

　　總之，兩個堆空間沒有釋放是因為指向它們的智能指針成員變量沒有析構導致引用計數不為0，這個智能指針成員變量沒有析構又是因為它們所屬的堆對象沒有析構，而這兩個堆對象沒有析構是因為它們被智能指針保管，該智能指針又被指向的堆對象的智能指針成員變量增加了引用計數。

　　

　　解決的辦法就是用weak_ptr取代智能指針成員變量，從而解決shared_ptr智能指針循環引用的問題。

 

　　shared_ptr智能指針循環引用問題一句話概括就是：要釋放的堆對象被該堆對象自己內部的智能指針成員變量增加引用計數阻止了。