STL一共給我們提供了四種智慧指標：auto_ptr、unique_ptr、shared_ptr和weak_ptr，auto_ptr是C++98提供的解決方案，C+11已將其摒棄，並提出了unique_ptr作為auto_ptr替代方案。雖然auto_ptr已被摒棄，但在實際專案中仍可使用，但建議使用較新的unique_ptr，因為unique_ptr比auto_ptr更加安全，後文會詳細敘述。shared_ptr和weak_ptr則是C+11從準標準庫Boost中引入的兩種智慧指標。此外，Boost庫還提出了boost::scoped_ptr、boost::scoped_array、boost::intrusive_ptr 等智慧指標，雖然尚未得到C++標準採納，但是實際開發工作中可以使用。

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]}$。

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過期時。要避免這種問題，方法有多種：
（1）定義陚值運算子，使之執行深複製。這樣兩個指標將指向不同的物件，其中的一個物件是另一個物件的副本，缺點是浪費空間，所以智慧指標都未採用此方案。
（2）建立所有權（ownership）概念。對於特定的物件，只能有一個智慧指標可擁有，這樣只有擁有物件的智慧指標的解構函式會刪除該物件。然後讓賦值操作轉讓所有權。這就是用於auto_ptr和unique_ptr 的策略，但unique_ptr的策略更嚴格。
（3）建立智慧更高的指標，跟蹤引用特定物件的智慧指標數。這稱為引用計數。例如，賦值時，計數將加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不能完成的功能
（3.1）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"));  

（3.2）管理動態陣列，因為unique_ptr有unique_ptr<X[]>過載版本，銷燬動態物件時呼叫delete[]。

unique_ptr<int[]> p (new int[3]{1,2,3});  
p[0] = 0;// 過載了operator[]

（3.3）自定義資源刪除操作(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.1shared_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）為基礎物件類實現智慧指標類
引用計數是實現智慧指標的一種通用方法。智慧指標將一個計數器與類指向的物件相關聯，引用計數跟蹤共有多少個類物件共享同一指標。它的具體做法如下：
（3.1）當建立智慧指標類的新物件時，初始化指標，並將引用計數設定為1；
（3.2）當能智慧指標類物件作為另一個物件的副本時，拷貝建構函式複製副本的指向輔助類物件的指標，並增加輔助類物件對基礎類物件的引用計數（加1）；
（3.3）使用賦值操作符對一個智慧指標類物件進行賦值時，處理複雜一點：先使左運算元的引用計數減1（為何減1：因為指標已經指向別的地方），如果減1後引用計數為0，則釋放指標所指物件記憶體。然後增加右運算元所指物件的引用計數（為何增加：因為此時做運算元指向物件即右運算元指向物件）。
（3.4）完成解構函式：呼叫解構函式時，解構函式先使引用計數減1，如果減至0則delete物件。

做好前面的準備後，我們可以為基礎物件類Point書寫一個智慧指標類了。根據引用計數實現關鍵點，我們可以寫出如下智慧指標類：

class SmartPtr
{
public:
    SmartPtr(Point *ptr) :rp(new RefPtr(ptr)){} 
    SmartPtr(const SmartPtr &sp):rp(sp.rp){++rp->count;}
    
//過載賦值運算子
SmartPtr& operator=(const SmartPtr& rhs) 
{
        ++rhs.rp->count;    
        if (--rp->count == 0)    
            delete rp;
        rp = rhs.rp;
        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=sptr1; //呼叫賦值操作符，此時計數為conut=3
                cout<<"sptr3:"<<(*sptr3).getX()<<","<<(*sptr3).getY()<<endl;
            }
            //此時count=2
        }
        //此時count=1；
    }
    //此時count=0；pa物件被delete掉
    cout << pa->getX ()<< endl;
    system("pause");
    return 0;
}

執行結果：

sptr1:10,20
sptr2:10,20
sptr3:10,20
還有2個指標指向基礎物件
還有1個指標指向基礎物件
7244864

如期，在離開大括號後，共享基礎物件的指標從3->2->1->0變換，最後計數為0時，pa物件被delete，此時使用getX()已經獲取不到原來的值。

（5）對智慧指標的改進
目前這個智慧指標智慧用於管理Point類的基礎物件，如果此時定義了個矩陣的基礎物件類，那不是還得重新寫一個屬於矩陣類的智慧指標類嗎？但是矩陣類的智慧指標類設計思想和Point類一樣啊，就不能借用嗎？答案當然是能，那就是使用模板技術。為了使我們的智慧指標適用於更多的基礎物件類，我們有必要把智慧指標類通過模板來實現。這裡貼上上面的智慧指標類的模板版：

//模板類作為友元時要先有宣告
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;
    system("pause");
    return 0;
}

測試結果如下：

sptr1:10
sptr2:10
sptr3:5
還有2個指標指向基礎物件
還有1個指標指向基礎物件
3968064

4.weak_ptr

4.1weak_ptr簡介

weak_ptr被設計為與shared_ptr共同工作，可以從一個shared_ptr或者另一個weak_ptr物件構造而來。weak_ptr是為了配合shared_ptr而引入的一種智慧指標，它更像是shared_ptr的一個助手而不是智慧指標，因為它不具有普通指標的行為，沒有過載operator*和->，因此取名為weak，表明其是功能較弱的智慧指標。它的最大作用在於協助shared_ptr工作，可獲得資源的觀測權，像旁觀者那樣觀測資源的使用情況。觀察者意味著weak_ptr只對shared_ptr 進行引用，而不改變其引用計數，當被觀察的shared_ptr失效後，相應的weak_ptr也相應失效。

4.2用法

使用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;
    system("pause");
    return 0;
}

程式輸出：

int：100

從上面可以看到，儘管以shared_ptr來構造weak_ptr，但是weak_ptr內部的引用計數並沒有什麼變化。

4.3weak_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。這樣的情況包括：
（1.1）有一個指標陣列，並使用一些輔助指標來標示特定的元素，如最大的元素和最小的元素；
（1.2）兩個物件都包含指向第三個物件的指標；
（1.3）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 << *a << ' ';
}

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類似。

參考文獻