模擬實現的簡單的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思想，而且利用引用計數，解決了淺拷貝的問題。
至於它的問題，需要特定的場景。

建立一個場景：

struct ListNode
{
    ListNode()
        :_data(1)
        , _next(NULL)
        , _prev(NULL)
    {}

    int _data;
    SharedPtr<ListNode> _next;
    Shared_ptr<ListNode> _prev;
};

這是一個雙向連結串列，next和prev都是SharedPtr智慧指標，也就是說_next和_prev裡不僅有一個ListNode*的指標，還有一個引用計數。
接下來例項化出物件：

SharedPtr<ListNode> cur(new ListNode);
SharedPtr<ListNode> next(new ListNode);

先來說兩個SharedPtr物件：cur和next的物件模型：
首先我們建立了兩個SharedPtr物件：cur，next，所以兩個物件必須都各自有一個ListNode*類的指標和一個引用計數；

這兩個物件的ListNode*類指標自然指向ListNode物件，引用計數初始化為1；

接下來需要說ListNode的物件模型：
由於使用得是new，所以開闢空間的同時還呼叫了ListNode的建構函式：

而在ListNode的建構函式裡又分別呼叫了_next和_prev的建構函式：

所以說ListNode物件模型就是：兩個SharedPtr物件_prev和_next，物件的_ptr被初始化為NULL，引用計數被初始化為0，另外還有一個數據_data：

綜上，cur和next物件的_ptr分別指向了一個ListNode物件，而ListNode物件內有兩個智慧指標_prev和_next，它們分別又有一個_ptr和一個引用計數，_ptr被初始化為NULL，引用計數被初始化為1。
如下圖所示：

接下來賦值：

    cur->_next = next;
    next->_prev = cur;

在這裡是呼叫了SharedPtr的operator=，把next賦值給了cur的_next，把cur賦值給了next的_prev：

接下來通過監視看：

SharedPtr<ListNode> cur(new ListNode);
SharedPtr<ListNode> next(new ListNode);

這兩句程式碼構造了兩個物件cur和next，它們分別有_ptr和_refCount,它們的_ptr指向一個ListNode型別的物件，_*refcount初始化為1。
兩個ListNode物件內有分別有兩個物件_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的物件。

這樣的話出了作用域呼叫解構函式，就可以清理乾淨，不會存在記憶體洩漏。