第C++11智能指針的具體使用示例詳解：

利用引用計數(shù)簡單的實現(xiàn)SharedPtr，了解原理：

templateclassT

classSharedPtr

public:

SharedPtr(T*ptr)

:_ptr(ptr)

,_count(newint(1))

SharedPtr(constSharedPtrTsp)

:_ptr(sp._ptr)

,_count(sp._count)

//計數(shù)器累加

++(*_count);

SharedPtroperator=(constSharedPtrTsp)

//判斷管理的是否是同一份資源

if(_ptr!=sp._ptr)

//計數(shù)-1，判斷之前管理的資源是否需要釋放

if((--(*_count))==0)

delete_ptr;

delete_count;

_ptr=sp._ptr;

_count=sp._count;

//計數(shù)器累加

++(*_count);

return*this;

T*operator-()

return_ptr;

Toperator*()

return*_ptr;

~SharedPtr()

if(--(*_count)==0)

delete_ptr;

delete_count;

_ptr=nullptr;

_count=nullptr;

private:

T*_ptr;

int*_count;//給每份資源開辟一個計數(shù)器

但是還存在一個線程安全的問題：

智能指針對象中引用計數(shù)是多個智能指針對象共享的，兩個線程中智能指針的引用計數(shù)同時++或–，這個操作不是原子的，引用計數(shù)原來是1，++了兩次，可能還是2。這樣引用計數(shù)就錯亂了。會導致資源未釋放或者程序崩潰的問題。所以只能指針中引用計數(shù)++、--是需要加鎖的，也就是說引用計數(shù)的操作是線程安全的。

智能指針管理的對象存放在堆上，兩個線程中同時去訪問，會導致線程安全問題。

這里我們通過加鎖來解決線程安全問題：

templateclassT

classSharedPtr

public:

SharedPtr(T*ptr)

:_ptr(ptr)

,_count(newint(1))

,_mutex(newmutex)

SharedPtr(constSharedPtrTsp)

:_ptr(sp._ptr)

,_count(sp._count)

,_mutex(sp._mutex)

//計數(shù)器累加

AddCount();

SharedPtroperator=(constSharedPtrTsp)

//判斷管理的是否是同一份資源

if(_ptr!=sp._ptr)

//計數(shù)-1，判斷之前管理的資源是否需要釋放

if(SubCount()==0)

delete_ptr;

delete_count;

delete_mutex;

_ptr=sp._ptr;

_count=sp._count;

_mutex=sp._mutex;

//計數(shù)器累加

AddCount();

return*this;

//線程安全的累加器

intAddCount()

//加鎖

_mutex-lock();

++(*_count);

_mutex-unlock();

return*_count;

intSubCount()

_mutex-lock();

--(*_count);

_mutex-unlock();

return*_count;

T*operator-()

return_ptr;

Toperator*()

return*_ptr;

~SharedPtr()

if(SubCount()==0)

delete_ptr;

delete_count;

delete_mutex;

_ptr=nullptr;

_count=nullptr;

_mutex=nullptr;

private:

T*_ptr;

int*_count;//給每份資源開辟一個計數(shù)器

mutex*_mutex;//每一份資源有一個獨立的鎖

shared_ptr的循環(huán)引用

循環(huán)引用的場景：

structListNode

int_data;

shared_ptrListNode_prev;

shared_ptrListNode_next;

~ListNode(){cout"~ListNode()"endl;}

voidtest()

shared_ptrListNodenode1(newListNode);

shared_ptrListNodenode2(newListNode);

node1-_next=node2;

node2-_prev=node1;

node1和node2兩個智能指針對象指向兩個節(jié)點，兩個節(jié)點的引用計數(shù)都是1。node1-next指向node2，node2-prev指向node1，兩個節(jié)點的引用計數(shù)都變成2。程序運行完之后，析構node1和node2，node1和node2所指向的節(jié)點引用計數(shù)分別減1，但是node1-next指向下面節(jié)點，node2-prev指向上面節(jié)點，此時，兩個節(jié)點的引用計數(shù)都為1，所以兩個節(jié)點不能析構。

引用計數(shù)為0時，如果要析構node1節(jié)點，就先要去析構node1中的自定義結構，然后再析構node1。也就是說node1-next析構了，node2就釋放了；node2-prev析構了，node1就釋放了。但是_next屬于node的成員，node1釋放了，_next才會析構，而node1由_prev管理，_prev屬于node2成員，所以這就叫循環(huán)引用，誰也不會釋放。

解決方案：

在引用計數(shù)的場景下，把節(jié)點中的_prev和_next改成weak_ptr就可以了

原理就是，node1-_next=node2和node2-_prev=node1時weak_ptr的_next和_prev不會增加node1和node2的引用計數(shù)。

weak_ptr最大作用就是解決shared_ptr的循環(huán)引用

structListNode

int_data;

weak_ptrListNode_prev;

weak_ptrListNode_next;

~ListNode(){cout"~ListNode()"endl;}

voidtest()

shared_ptrListNodenode1(newListNode);

shared_ptrListNodenode2(newListNode);

node1-_next=node2;

node2-_prev=node1;

注意：

weak_ptr不能單獨使用，