一、前序
什么是智能指針？
——是一個類，用來存儲指針（指向動態分配對象也就是堆中對象的的指針）。
c++的內存管理是讓很多人頭疼的事，當我們寫一個new語句時，一般就會立即把delete語句直接也寫了，但是我們不能避免程序還未執行到delete時就跳轉了或者在函數中沒有執行到最后的delete語句就返回了，如果我們不在每一個可能跳轉或者返回的語句前釋放資源，就會造成內存泄露。使用智能指針可以很大程度上的避免這個問題，因為智能指針就是一個類，當超出了類的作用域是，類會自動調用析構函數，析構函數會自動釋放資源。
二、unique_ptr
unique_ptr 是auto_ptr的升級版，並且auto_ptr在c++11中已經棄用。
unique_ptr 是一個獨享所有權的智能指針：
1、擁有它指向的對象
2、無法進行復制構造，無法進行復制賦值操作。即無法使兩個unique_ptr指向同一個對象。但是可以進行移動構造和移動賦值操作
3、保存指向某個對象的指針，當它本身被刪除釋放的時候，會使用給定的刪除器釋放它指向的對象
unique_ptr 可以實現如下功能：
1、為動態申請的內存提供異常安全
2、講動態申請的內存所有權傳遞給某函數
3、從某個函數返回動態申請內存的所有權
4、在容器中保存指針
5、auto_ptr 應該具有的功能
我們可以通過“.”操作訪問指針，通過“->”來訪問它指向的對象，shared_ptr 是一樣的。
unique_ptr<PTest> p1(new PTest("ceshi1")); unique_ptr<PTest> p2(new PTest("p2 test")); p1->print(); p1->set("ceshi2"); p1->print(); //p1.release(); p1.reset(); p1 = std::move(p2); if (p2 == nullptr) { std::cout << "p2 is nullptr" << endl; } p1->print(); PTest *p = p1.release(); p->print(); p2.reset(p); p2->print(); p1 = function(); p1->print();
注意release函數是讓指針和指針指向的對象脫離關系，並沒銷毀，要想銷毀，調用reset一個空對象
三、shared_ptr
從名字share就可以看出了資源可以被多個指針共享，它使用計數機制來表明資源被幾個指針共享。可以通過成員函數use_count()來查看資源的所有者個數。出了可以通過new來構造，還可以通過傳入auto_ptr, unique_ptr,weak_ptr來構造。當我們調用release()時，當前指針會釋放資源所有權，計數減一。當計數等於0時，資源（指向的對象）會被釋放。此處調動reset不能銷毀對象，只有當計數為0時候才可以。
多線程調用它指向的對象的時候，一定要加鎖。
對於動態數組的操作unique_ptr 可以自動上釋放，shared_ptr不可以，需要添加一個刪除器，即一個lambd表達式
shared_ptr<PTest>p3(new PTest("p3:from shared_ptr")); p3->print(); shared_ptr<PTest>p4(new PTest("p4:from shared_ptr")); p4->print(); shared_ptr<PTest>p5(p4); p5->print(); std::cout<< p5.use_count()<<endl; p4.reset(); std::cout << p5.use_count()<<endl; p5.reset(); std::cout << p5.use_count() << endl; std::getchar(); return 0;
四、week_ptr——為了解決循環引用的問題
weak_ptr是用來解決shared_ptr相互引用時的死鎖問題,如果說兩個shared_ptr相互引用,那么這兩個指針的引用計數永遠不可能下降為0,資源永遠不會釋放。它是對對象的一種弱引用，不會增加對象的引用計數，和shared_ptr之間可以相互轉化，shared_ptr可以直接賦值給它，它可以通過調用lock函數來獲得shared_ptr。
weak_ptr沒有重載 * 和 -> ，所以並不能直接使用資源。但可以使用lock()獲得一個可用的shared_ptr對象，
如果對象已經死了，lock()會失敗，返回一個空的shared_ptr。
void runGame(){
std::shared_ptr<Monster> monster1(new Monster());
std::weak_ptr<Monster> r_monster1 = monster1;
r_monster1->doSomething();//Error! 編譯器出錯！weak_ptr沒有重載* 和 -> ，無法直接當指針用
std::shared_ptr<Monster> s_monster1 = r_monster1.lock();//OK!可以通過weak_ptr的lock方法獲得shared_ptr。
}
auto_ptr盡量不要用！
1.unique_ptr
unique_ptr 由 C++11 引入，旨在替代不安全的 auto_ptr。unique_ptr 是一種定義在頭文件<memory>中的智能指針。它持有對對象的獨有權——兩個unique_ptr不能指向一個對象，即 unique_ptr 不共享它所管理的對象。它無法復制到其他 unique_ptr，無法通過值傳遞到函數，也無法用於需要副本的任何標准模板庫 （STL）算法。只能移動 unique_ptr，即對資源管理權限可以實現轉移。這意味着，內存資源所有權可以轉移到另一個 unique_ptr，並且原始 unique_ptr 不再擁有此資源。實際使用中，建議將對象限制為由一個所有者所有，因為多個所有權會使程序邏輯變得復雜。因此，當需要智能指針用於存 C++ 對象時，可使用 unique_ptr，構造 unique_ptr 時，可使用 make_unique Helper 函數。
下圖演示了兩個 unique_ptr 實例之間的所有權轉換。
unique_ptr 與原始指針一樣有效，並可用於 STL 容器。將 unique_ptr 實例添加到 STL 容器運行效率很高，因為通過 unique_ptr 的移動構造函數，不再需要進行復制操作。unique_ptr 指針與其所指對象的關系：在智能指針生命周期內，可以改變智能指針所指對象，如創建智能指針時通過構造函數指定、通過 reset 方法重新指定、通過 release 方法釋放所有權、通過移動語義轉移所有權，unique_ptr 還可能沒有對象，這種情況被稱為 empty。[6] ^{[6]}
[6]
。
unique_ptr的基本操作有：
//智能指針的創建
unique_ptr<int> u_i; //創建空智能指針
u_i.reset(new int(3)); //綁定動態對象
unique_ptr<int> u_i2(new int(4));//創建時指定動態對象
unique_ptr<T,D> u(d); //創建空 unique_ptr，執行類型為 T 的對象，用類型為 D 的對象 d 來替代默認的刪除器 delete
//所有權的變化
int *p_i = u_i2.release(); //釋放所有權
unique_ptr<string> u_s(new string("abc"));
unique_ptr<string> u_s2 = std::move(u_s); //所有權轉移(通過移動語義)，u_s所有權轉移后，變成“空指針”
u_s2.reset(u_s.release()); //所有權轉移
u_s2=nullptr;//顯式銷毀所指對象，同時智能指針變為空指針。與u_s2.reset()等價
2.auto_ptr
auto_ptr 同樣是 STL 智能指針家族的成員之一，由 C++98 引入，定義在頭文件<memory>。其功能和用法類似於 unique_ptr，由 new expression 獲得對象，在 auto_ptr 對象銷毀時，他所管理的對象也會自動被 delete 掉。
auto_ptr 從 C++98 使用至今，為何從 C++11 開始，引入unique_ptr 來替代 auto_ptr 呢？原因主要有如下幾點：
（1）基於安全考慮。
先來看下面的賦值語句:
auto_ptr< string> ps (new string ("I reigned lonely as a cloud.”）;
auto_ptr<string> vocation;
vocaticn = ps;
上述賦值語句將完成什么工作呢？如果 ps 和 vocation 是常規指針，則兩個指針將指向同一個 string 對象。這是不能接受的，因為程序將試圖刪除同一個對象兩次，一次是 ps 過期時，另一次是 vocation 過期時。要避免這種問題，方法有多種：
（a）定義陚值運算符，使之執行深復制。這樣兩個指針將指向不同的對象，其中的一個對象是另一個對象的副本，缺點是浪費空間，所以智能指針都未采用此方案。
（b）建立所有權（ownership）概念。對於特定的對象，只能有一個智能指針可擁有，這樣只有擁有對象的智能指針的析構函數會刪除該對象。然后讓賦值操作轉讓所有權。這就是用於 auto_ptr 和 unique_ptr 的策略，但 unique_ptr 的策略更嚴格。
（c）創建智能更高的指針，跟蹤引用特定對象的智能指針數。這稱為引用計數。例如，賦值時，計數將加 1，而指針過期時，計數將減 1,。當減為 0 時才調用 delete。這是 shared_ptr 采用的策略。
當然，同樣的策略也適用於復制構造函數，即auto_ptr<string> vocation(ps)時也需要上面的策略。每種方法都有其用途，但為何要摒棄 auto_ptr 呢？
下面舉個例子來說明。
#include <iostream> #include <string> #include <memory> using namespace std; int main() { auto_ptr<string> films[5] ={ auto_ptr<string> (new string("Fowl Balls")), auto_ptr<string> (new string("Duck Walks")), auto_ptr<string> (new string("Chicken Runs")), auto_ptr<string> (new string("Turkey Errors")), auto_ptr<string> (new string("Goose Eggs")) }; auto_ptr<string> pwin; pwin = films[2]; // films[2] loses ownership. 將所有權從films[2]轉讓給pwin，此時films[2]不再引用該字符串從而變成空指針 cout << "The nominees for best avian baseballl film are\n"; for(int i = 0; i < 5; ++i) { cout << *films[i] << endl; } cout << "The winner is " << *pwin << endl; return 0; }
運行下發現程序崩潰了，原因在上面注釋已經說的很清楚，films[2] 已經是空指針了，下面輸出訪問空指針當然會崩潰了。但這里如果把 auto_ptr 換成 shared_ptr 或 unique_ptr 后，程序就不會崩潰，原因如下：
使用 shared_ptr 時運行正常，因為 shared_ptr 采用引用計數，pwin 和 films[2] 都指向同一塊內存，在釋放空間時因為事先要判斷引用計數值的大小因此不會出現多次刪除一個對象的錯誤。
使用 unique_ptr 時編譯出錯，與 auto_ptr 一樣，unique_ptr 也采用所有權模型，但在使用 unique_ptr 時，程序不會等到運行階段崩潰，而在編譯期因下述代碼行出現錯誤：
unique_ptr<string> pwin; pwin = films[2]; //films[2] loses ownership
指導你發現潛在的內存錯誤。這就是為何要摒棄 auto_ptr 的原因，一句話總結就是：避免因潛在的內存問題導致程序崩潰。
從上面可見，unique_ptr 比 auto_ptr 更加安全，因為 auto_ptr 有拷貝語義，拷貝后原對象變得無效，再次訪問原對象時會導致程序崩潰；unique_ptr 則禁止了拷貝語義，但提供了移動語義，即可以使用std::move() 進行控制權限的轉移，如下代碼所示：
unique_ptr<string> upt(new string("lvlv")); unique_ptr<string> upt1(upt); //編譯出錯，已禁止拷貝 unique_ptr<string> upt1=upt; //編譯出錯，已禁止拷貝 unique_ptr<string> upt1=std::move(upt); //控制權限轉移 auto_ptr<string> apt(new string("lvlv")); auto_ptr<string> apt1(apt); //編譯通過 auto_ptr<string> apt1=apt; //編譯通過
這里要注意，在使用std::move將unique_ptr的控制權限轉移后，不能夠再通過unique_ptr來訪問和控制資源了，否則同樣會出現程序崩潰。我們可以在使用unique_ptr訪問資源前，使用成員函數get()進行判空操作。
unique_ptr<string> upt1=std::move(upt); //控制權限轉移 if(upt.get()!=nullptr) //判空操作更安全 { //do something }
（2）unique_ptr 不僅安全，而且靈活。
如果 unique_ptr 是個臨時右值，編譯器允許拷貝語義。參考如下代碼：
unique_ptr<string> demo(const char* s) { unique_ptr<string> temp (new string(s))； return temp； }
//假設編寫了如下代碼：
unique_ptr<string> ps; ps = demo('Uniquely special")；
demo() 返回一個臨時 unique_ptr，然后 ps 接管了臨時對象 unique_ptr 所管理的資源，而返回時臨時的 unique_ptr 被銷毀，也就是說沒有機會使用 unique_ptr 來訪問無效的數據，換句話來說，這種賦值是不會出現任何問題的，即沒有理由禁止這種賦值。實際上，編譯器確實允許這種賦值。相對於 auto_ptr 任何情況下都允許拷貝語義，這正是 unique_ptr 更加靈活聰明的地方。
（3）擴展 auto_ptr 不能完成的功能。
（a）unique_ptr 可放在容器中，彌補了 auto_ptr 不能作為容器元素的缺點。
//方式一： vector<unique_ptr<string>> vs { new string{“Doug”}, new string{“Adams”} }; //方式二： vector<unique_ptr<string>>v; unique_ptr<string> p1(new string("abc"));
（b）管理動態數組，因為 unique_ptr 有 unique_ptr<X[]> 重載版本，銷毀動態對象時調用 delete[]。
unique_ptr<int[]> p (new int[3]{1,2,3}); p[0] = 0;// 重載了operator[]
（c）自定義資源刪除操作（Deleter）。unique_ptr 默認的資源刪除操作是 delete/delete[]，若需要，可以進行自定義：
void end_connection(connection *p) { disconnect(*p); } //資源清理函數
//資源清理器的“類型”
unique_ptr<connection, decltype(end_connection)*> p(&c, end_connection);// 傳入函數名，會自動轉換為函數指針
綜上所述，基於 unique_ptr 的安全性和擴充的功能，unique_ptr 成功的將 auto_ptr 取而代之。
3.shared_ptr
3.1 shared_ptr 簡介
shared_ptr 是一個標准的共享所有權的智能指針，允許多個指針指向同一個對象，定義在 memory 文件中，命名空間為 std。shared_ptr最初實現於Boost庫中，后由 C++11 引入到 C++ STL。shared_ptr 利用引用計數的方式實現了對所管理的對象的所有權的分享，即允許多個 shared_ptr 共同管理同一個對象。像 shared_ptr 這種智能指針，《Effective C++》稱之為“引用計數型智能指針”（reference-counting smart pointer，RCSP）。
shared_ptr 是為了解決 auto_ptr 在對象所有權上的局限性（auto_ptr 是獨占的），在使用引用計數的機制上提供了可以共享所有權的智能指針，當然這需要額外的開銷：
（1）shared_ptr 對象除了包括一個所擁有對象的指針外，還必須包括一個引用計數代理對象的指針；
（2）時間上的開銷主要在初始化和拷貝操作上， * 和 -> 操作符重載的開銷跟 auto_ptr 是一樣；
（3）開銷並不是我們不使用 shared_ptr 的理由,，永遠不要進行不成熟的優化，直到性能分析器告訴你這一點。
3.2 通過輔助類模擬實現 shared_ptr
（1）基礎對象類
首先，我們來定義一個基礎對象類 Point 類，為了方便后面我們驗證智能指針是否有效，我們為 Point 類創建如下接口：
class Point { private: int x, y; public: Point(int xVal = 0, int yVal = 0) :x(xVal), y(yVal) {} int getX() const { return x; } int getY() const { return y; } void setX(int xVal) { x = xVal; } void setY(int yVal) { y = yVal; } };
（2）輔助類
在創建智能指針類之前，我們先創建一個輔助類。這個類的所有成員皆為私有類型，因為它不被普通用戶所使用。為了只為智能指針使用，還需要把智能指針類聲明為輔助類的友元。這個輔助類含有兩個數據成員：計數count 與基礎對象指針。也即輔助類用以封裝使用計數與基礎對象指針。
class RefPtr { private: friend class SmartPtr; RefPtr(Point *ptr):p(ptr),count(1){ } ~RefPtr(){delete p;} int count; Point *p; };
（3）為基礎對象類實現智能指針類
引用計數是實現智能指針的一種通用方法。智能指針將一個計數器與類指向的對象相關聯，引用計數跟蹤共有多少個類對象共享同一指針。它的具體做法如下：
（a）當創建智能指針類的新對象時，初始化指針，並將引用計數設置為1；
（b）當能智能指針類對象作為另一個對象的副本時，拷貝構造函數復制副本的指向輔助類對象的指針，並增加輔助類對象對基礎類對象的引用計數（加1）；
（c）使用賦值操作符對一個智能指針類對象進行賦值時，處理復雜一點：先使左操作數的引用計數減 1（為何減 1：因為指針已經指向別的地方），如果減1后引用計數為 0，則釋放指針所指對象內存。然后增加右操作數所指對象的引用計數（為何增加：因為此時做操作數指向對象即右操作數指向對象）；
（d）完成析構函數：調用析構函數時，析構函數先使引用計數減 1，如果減至 0 則 delete 對象。
做好前面的准備后，我們可以為基礎對象類 Point 書寫一個智能指針類了。根據引用計數實現關鍵點，我們可以寫出如下智能指針類：
class SmartPtr { public: //構造函數 SmartPtr() { rp = nullptr; } SmartPtr(Point *ptr):rp(new RefPtr(ptr)) {} SmartPtr(const SmartPtr &sp):rp(sp.rp) { ++rp->count; cout << "in copy constructor" <<endl; } //重載賦值運算符 SmartPtr& operator=(const SmartPtr& rhs) { ++rhs.rp->count; if (rp != nullptr && --rp->count == 0) { delete rp; } rp = rhs.rp; cout << "in assignment operator" << endl; return *this; } //重載->操作符 Point* operator->() { return rp->p; } //重載*操作符 Point& operator*() { return *(rp->p); } ~SmartPtr() { if (--rp->count == 0) delete rp; else cout << "還有" << rp->count << "個指針指向基礎對象" << endl; } private: RefPtr* rp; };
（4）智能指針類的使用與測試
至此，我們的智能指針類就完成了，我們可以來看看如何使用。
int main() { //定義一個基礎對象類指針 Point *pa = new Point(10, 20); //定義三個智能指針類對象，對象都指向基礎類對象 pa //使用花括號控制三個智能指針的生命周期，觀察計數的變化 { SmartPtr sptr1(pa);//此時計數 count=1 cout <<"sptr1:"<<sptr1->getX()<<","<<sptr1->getY()<<endl; { SmartPtr sptr2(sptr1); //調用拷貝構造函數，此時計數為 count=2 cout<<"sptr2:" <<sptr2->getX()<<","<<sptr2->getY()<<endl; { SmartPtr sptr3; SmartPtr sptr3=sptr1; //調用賦值操作符，此時計數為 conut=3 cout<<"sptr3:"<<(*sptr3).getX()<<","<<(*sptr3).getY()<<endl; } //此時count=2 } //此時count=1； } //此時count=0；對象 pa 被 delete 掉 cout << pa->getX() << endl; return 0; }
運行結果：
sptr1:10,20
in copy constructor
sptr2:10,20
in assignment operator
sptr3:10,20
還有2個指針指向基礎對象
還有1個指針指向基礎對象
-572662307
如期，在離開大括號后，共享基礎對象的指針從 3->2->1->0 變換，最后計數為 0 時，pa 對象被 delete，此時使用 getX() 已經獲取不到原來的值。
（5）對智能指針的改進
目前這個智能指針只能用於管理 Point 類的基礎對象，如果此時定義了個矩陣的基礎對象類，那不是還得重新寫一個屬於矩陣類的智能指針類嗎？但是矩陣類的智能指針類設計思想和 Poin t類一樣啊，就不能借用嗎？答案當然是能，那就是使用模板技術。為了使我們的智能指針適用於更多的基礎對象類，我們有必要把智能指針類通過模板來實現。這里貼上上面的智能指針類的模板版本：
//模板類作為友元時要先有聲明 template <typename T> class SmartPtr; //輔助類 template <typename T> class RefPtr { private: //該類成員訪問權限全部為private，因為不想讓用戶直接使用該類 friend class SmartPtr<T>; //定義智能指針類為友元，因為智能指針類需要直接操縱輔助類 //構造函數的參數為基礎對象的指針 RefPtr(T *ptr):p(ptr), count(1) {} //析構函數 ~RefPtr() { delete p; } //引用計數 int count; //基礎對象指針 T *p; }; //智能指針類 template <typename T> class SmartPtr { public: //構造函數 SmartPtr(T *ptr) :rp(new RefPtr<T>(ptr)) {} //拷貝構造函數 SmartPtr(const SmartPtr<T> &sp):rp(sp.rp) { ++rp->count; } //重載賦值操作符 SmartPtr& operator=(const SmartPtr<T>& rhs) { ++rhs.rp->count; //首先將右操作數引用計數加1， if (--rp->count == 0) //然后將引用計數減1，可以應對自賦值 delete rp; rp = rhs.rp; return *this; } //重載*操作符 T & operator *() { return *(rp->p); } //重載->操作符 T* operator ->() { return rp->p; } //析構函數 ~SmartPtr() { if (--rp->count == 0) //當引用計數減為0時，刪除輔助類對象指針，從而刪除基礎對象 { delete rp; } else { cout << "還有" << rp->count << "個指針指向基礎對象" << endl; } } private: RefPtr<T> *rp; //輔助類對象指針 };
現在使用智能指針類模板來共享其它類型的基礎對象，以int為例：
int main() { //定義一個基礎對象類指針 int* ia = new int(10); { SmartPtr<int> sptr1(ia); cout <<"sptr1:"<<*sptr1<<endl; { SmartPtr<int> sptr2(sptr1); cout <<"sptr2:"<<*sptr2<<endl; *sptr2=5; { SmartPtr<int> sptr3=sptr1; cout <<"sptr3:"<<*sptr3<<endl; } } } //此時count=0；pa對象被delete掉 cout << *ia << endl; return 0; }
測試結果如下：
sptr1:10
sptr2:10
sptr3:5
還有2個指針指向基礎對象
還有1個指針指向基礎對象
3968064
4.weak_ptr
4.1 weak_ptr 簡介
weak_ptr 被設計為與 shared_ptr 共同工作，可以從一個 shared_ptr 或者另一個 weak_ptr 對象構造而來。weak_ptr 是為了配合 shared_ptr 而引入的一種智能指針，它更像是 shared_ptr 的一個助手而不是智能指針，因為它不具有普通指針的行為，沒有重載 operator* 和 operator-> ，因此取名為 weak，表明其是功能較弱的智能指針。它的最大作用在於協助 shared_ptr 工作，可獲得資源的觀測權，像旁觀者那樣觀測資源的使用情況。觀察者意味着 weak_ptr 只對 shared_ptr 進行引用，而不改變其引用計數，當被觀察的 shared_ptr 失效后，相應的 weak_ptr 也相應失效。
4.2 weak_ptr 用法
使用 weak_ptr 的成員函數 use_count() 可以觀測資源的引用計數，另一個成員函數 expired() 的功能等價於 use_count()==0，但更快，表示被觀測的資源（也就是 shared_ptr 管理的資源）已經不復存在。weak_ptr 可以使用一個非常重要的成員函數lock()從被觀測的 shared_ptr 獲得一個可用的 shared_ptr 管理的對象， 從而操作資源。但當 expired()==true 的時候，lock() 函數將返回一個存儲空指針的 shared_ptr。總的來說，weak_ptr 的基本用法總結如下：
weak_ptr<T> w; //創建空 weak_ptr，可以指向類型為 T 的對象
weak_ptr<T> w(sp); //與 shared_ptr 指向相同的對象，shared_ptr 引用計數不變。T必須能轉換為 sp 指向的類型
w=p; //p 可以是 shared_ptr 或 weak_ptr，賦值后 w 與 p 共享對象
w.reset(); //將 w 置空
w.use_count(); //返回與 w 共享對象的 shared_ptr 的數量
w.expired(); //若 w.use_count() 為 0，返回 true，否則返回 false
w.lock(); //如果 expired() 為 true，返回一個空 shared_ptr，否則返回非空 shared_ptr
下面是一個簡單的使用示例：
#include < assert.h> #include <iostream> #include <memory> #include <string> using namespace std; int main() { shared_ptr<int> sp(new int(10)); assert(sp.use_count() == 1); weak_ptr<int> wp(sp); //從 shared_ptr 創建 weak_ptr assert(wp.use_count() == 1); if (!wp.expired()) //判斷 weak_ptr 觀察的對象是否失效 { shared_ptr<int> sp2 = wp.lock();//獲得一個shared_ptr *sp2 = 100; assert(wp.use_count() == 2); } assert(wp.use_count() == 1); cout << "int:" << *sp << endl; return 0;
程序輸出：
int：100
1
從上面可以看到，盡管以 shared_ptr 來構造 weak_ptr，但是 weak_ptr內部的引用計數並沒有什么變化。
4.3 weak_ptr 的作用
現在要說的問題是，weak_ptr 到底有什么作用呢？從上面那個例子看來，似乎沒有任何作用。其實 weak_ptr 可用於打破循環引用。引用計數是一種便利的內存管理機制，但它有一個很大的缺點，那就是不能管理循環引用的對象。一個簡單的例子如下：
#include <iostream> #include <memory> class Woman; class Man { private: //std::weak_ptr<Woman> _wife; std::shared_ptr<Woman> _wife; public: void setWife(std::shared_ptr<Woman> woman) { _wife = woman; } void doSomthing() { if(_wife.lock()) {} } ~Man() { std::cout << "kill man\n"; } }; class Woman { private: //std::weak_ptr<Man> _husband; std::shared_ptr<Man> _husband; public: void setHusband(std::shared_ptr<Man> man) { _husband = man; } ~Woman() { std::cout <<"kill woman\n"; } }; int main(int argc, char** argv) { std::shared_ptr<Man> m(new Man()); std::shared_ptr<Woman> w(new Woman()); if(m && w) { m->setWife(w); w->setHusband(m); } return 0; }
在 Man 類內部會引用一個 Woman，Woman 類內部也引用一個 Man。當一個 man 和一個 woman 是夫妻的時候，他們直接就存在了相互引用問題。man 內部有個用於管理wife生命期的 shared_ptr 變量，也就是說 wife 必定是在 husband 去世之后才能去世。同樣的，woman 內部也有一個管理 husband 生命期的 shared_ptr 變量，也就是說 husband 必須在 wife 去世之后才能去世。這就是循環引用存在的問題：husband 的生命期由 wife 的生命期決定，wife 的生命期由 husband 的生命期決定，最后兩人都死不掉，違反了自然規律，導致了內存泄漏。
一般來講，解除這種循環引用有下面三種可行的方法：
（1）當只剩下最后一個引用的時候需要手動打破循環引用釋放對象。
（2）當 parent 的生存期超過 children 的生存期的時候，children 改為使用一個普通指針指向 parent。
（3）使用弱引用的智能指針打破這種循環引用。
雖然這三種方法都可行，但方法 1 和方法 2 都需要程序員手動控制，麻煩且容易出錯。這里主要介紹一下第三種方法，使用弱引用的智能指針std:weak_ptr 來打破循環引用。
weak_ptr 對象引用資源時不會增加引用計數，但是它能夠通過 lock() 方法來判斷它所管理的資源是否被釋放。做法就是上面的代碼注釋的地方取消注釋，取消 Woman 類或者 Man 類的任意一個即可，也可同時取消注釋，全部換成弱引用 weak_ptr。
另外很自然地一個問題是：既然 weak_ptr 不增加資源的引用計數，那么在使用 weak_ptr 對象的時候，資源被突然釋放了怎么辦呢？不用擔心，因為不能直接通過 weak_ptr 來訪問資源。那么如何通過 weak_ptr 來間接訪問資源呢？答案是在需要訪問資源的時候 weak_ptr 為你生成一個shared_ptr，shared_ptr 能夠保證在 shared_ptr 沒有被釋放之前，其所管理的資源是不會被釋放的。創建 shared_ptr 的方法就是 lock() 成員函數。
注意： shared_ptr 實現了 operator bool() const 方法來判斷被管理的資源是否已被釋放。
5.如何選擇智能指針
上文簡單地介紹了 C++ STL 的四種智能指針。當然，除了 STL 的智能指針，C++ 准標准庫 Boost 的智能指針，比如 boost::scoped_ptr、boost::shared_array、boost::intrusive_ptr 也可以在編程實踐中拿來使用，但這里不做進一步的介紹，有興趣的讀者可以參考：C++ 智能指針詳解。
在了解 STL 的四種智能指針后，大家可能會想另一個問題：在實際應用中，應使用哪種智能指針呢？
下面給出幾個使用指南。
（1）如果程序要使用多個指向同一個對象的指針，應選擇 shared_ptr。這樣的情況包括：
（a）將指針作為參數或者函數的返回值進行傳遞的話，應該使用 shared_ptr；
（b）兩個對象都包含指向第三個對象的指針，此時應該使用 shared_ptr 來管理第三個對象；
（c）STL 容器包含指針。很多 STL 算法都支持復制和賦值操作，這些操作可用於 shared_ptr，但不能用於 unique_ptr（編譯器發出warning）和 auto_ptr（行為不確定）。如果你的編譯器沒有提供 shared_ptr，可使用 Boost 庫提供的 shared_ptr。
（2）如果程序不需要多個指向同一個對象的指針，則可使用 unique_ptr。如果函數使用 new 分配內存，並返還指向該內存的指針，將其返回類型聲明為 unique_ptr 是不錯的選擇。這樣，所有權轉讓給接受返回值的 unique_ptr，而該智能指針將負責調用 delete。可將 unique_ptr 存儲到 STL 容器中，只要不調用將一個 unique_ptr 復制或賦值給另一個的算法（如 sort()）。例如，可在程序中使用類似於下面的代碼段。
unique_ptr<int> make_int(int n) { return unique_ptr<int>(new int(n)); } void show(unique_ptr<int>& p1) { cout << *p1 << ' '; } int main() { //... vector<unique_ptr<int>> vp(size); for(int i = 0; i < vp.size(); i++) { vp[i] = make_int(rand() % 1000); //copy temporary unique_ptr } vp.push_back(make_int(rand() % 1000)); //ok because arg is temporary for_each(vp.begin(), vp.end(), show); //use for_each()
其中 push_back 調用沒有問題，因為它返回一個臨時 unique_ptr，該 unique_ptr 被賦給 vp 中的一個 unique_ptr。另外，如果按值而不是按引用給 show() 傳遞對象，for_each() 將非法，因為這將導致使用一個來自 vp 的非臨時 unique_ptr 初始化 pi，而這是不允許的。前面說過，編譯器將發現錯誤使用 unique_ptr 的企圖。
在 unique_ptr 為右值時，可將其賦給 shared_ptr，這與將一個 unique_ptr 賦給另一個 unique_ptr 需要滿足的條件相同，即 unique_ptr 必須是一個臨時對象。與前面一樣，在下面的代碼中，make_int() 的返回類型為 unique_ptr<int>：
unique_ptr<int> pup(make_int(rand() % 1000)); // ok
shared_ptr<int> spp(pup); // not allowed, pup as lvalue
shared_ptr<int> spr(make_int(rand() % 1000)); // ok
模板 shared_ptr 包含一個顯式構造函數，可用於將右值 unique_ptr 轉換為 shared_ptr。shared_ptr 將接管原來歸 unique_ptr 所有的對象。
在滿足 unique_ptr 要求的條件時，也可使用 auto_ptr，但 unique_ptr 是更好的選擇。如果你的編譯器沒有unique_ptr，可考慮使用 Boost 庫提供的 scoped_ptr，它與 unique_ptr 類似。
（3）雖然說在滿足 unique_ptr 要求的條件時，使用 auto_ptr 也可以完成對內存資源的管理，但是因為 auto_ ptr 不夠安全，不提倡使用，即任何情況下都不應該使用 auto_ptr。
（4）為了解決 shared_ptr 的循環引用問題，我們可以祭出 weak_ptr。
（5）在局部作用域（例如函數內部或類內部），且不需要將指針作為參數或返回值進行傳遞的情況下，如果對性能要求嚴格，使用 scoped_ptr 的開銷較 shared_ptr 會小一些。
- 智能指針主要是使用構造和析構來管理資源的。
shared_ptr很好用也很難用，有兩種構造方式，使用引用計數實現多人同時管理一份資源。使用this的時候要格外注意。weak_ptr可以解決shared_ptr的循環引用問題。unique_ptr最像裸指針，但更為安全，保證資源的釋放，不能復制只能移動。- 智能指針帶來了性能問題，在不同場合可以選擇不同的解決方案。優先使用類的實例(如果內存足夠)，其次
unique_ptr，最后才是shared_ptr。