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智能指针循环引用问题一句话概括就是：要释放的堆对象被该堆对象自己内部的智能指针成员变量增加引用计数阻止了。