c++：分析智能指针shared_ptr存在的循环引用的缺陷

首先来回顾一下智能指针的历史：

以及在《c++:分析智能指针与发展历史》一文中模拟实现的简单的shared_ptr:

template <class T>class SharedPtr{public:    SharedPtr(T* ptr)        :_ptr(ptr)        , _refCount(new int(1))    {}    SharedPtr(SharedPtr<T>& sp)        :_ptr(sp._ptr)        , _refCount(sp._refCount)    {        ++(*_refCount);    }    SharedPtr<T>& operator=(SharedPtr<T>& sp)    {        if (_ptr != sp._ptr)        {            if (--(*_refCount) == 0)            {                delete _ptr;                delete _refCount;            }            _ptr = sp._ptr;            _refCount = sp._refCount;            ++(*_refCount);        }        return *this;    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }    ~SharedPtr()    {        if (--(*_refCount) == 0)        {            delete _ptr;            delete _refCount;        }    }private:    T* _ptr;    int* _refCount;};

shared_ptr不仅体现了RAII思想，而且多了一个int*型成员变量，用来引用计数，解决了浅拷贝的两个问题。（具体看我之前写的c++写时拷贝对引用计数有解析，这里我只分析shared_ptr的循环引用的问题）

那么这么完美的智能指针，到底有什么问题呢？

我来创建一个场景：

struct ListNode{    ListNode()        :_data(1)        , _next(NULL)        , _prev(NULL)    {}    int _data;    SharedPtr<ListNode> _next;    Shared_ptr<ListNode> _prev;};

这是一个简单的双向链表类。

void TestSharedPtrError(){    SharedPtr<ListNode> cur(new ListNode);    SharedPtr<ListNode> next(new ListNode);    cur->_next = next;    next->_prev = cur;}

接下来，我利用SharedPtr实例化出对象，如图：

首先 SharedPtr cur(new ListNode);
SharedPtr next(new ListNode);
这两句代码构造了两个对象cur和next，它们分别有_ptr和_refcount,它们的_ptr指向一个ListNode类型的对象，_*refcount为1。
两个对象内有分别有两个对象_next和_prev它们的_ptr初始化为NULL，_refcount为1（参见构造函数）请看监视：

这两段代码：
cur->_next = next;
next->_prev = cur;
调用了operator=，因为_next和_prev已经被初始化。
所以说，在operaotor=函数里，我已经标明了指向关系，并且现在cur和next的引用计数都变为2。
请看监视：

    出了cur和next作用域，会调用析构函数，那么会先调用_next的析构函数，再调用_cur的析构函数，但是这会陷入一个循环，因为释放关系中你的释放需要我，我的释放需要你，谁都不肯放手，自然会出现内存泄漏。    如何解决问题，引入了wead_ptr，这里我也是简单的模拟实现它：

template <class T>class WeakPtr{public:    WeakPtr(const SharedPtr<T>& sp)        :_ptr(sp._ptr)    {}    WeakPtr<T>& operator=(SharedPtr<T>& sp)    {        _ptr = sp._ptr;        return *this;    }private:    T* _ptr;};

然后对以上代码进行修改：

struct ListNode{    ListNode()        :_data(1)        , _next(NULL)        , _prev(NULL)    {}    int _data;    WeakPtr<ListNode> _next;    WeakPtr<ListNode> _prev;};

那么

void TestSharedPtrError(){    SharedPtr<ListNode> cur(new ListNode);    SharedPtr<ListNode> next(new ListNode);    cur->_next = next;    next->_prev = cur;}

就是Shraed_ptr的对象赋值给WeakPtr的对象。

这样的话出了作用域调用析构函数，就可以清理干净，不会存在内存泄漏。