C++智慧指標是面試中經常會問到的一個經典知識點，本身使用也具有很大的意義。本文從下面三個方面對智慧指標的內容進行整理，以期對智慧指標能夠有一個較為清晰的認識：
1 智慧指標的實現原理
2 常用的智慧指標
3 智慧指標的實現

1、智慧指標的實現原理：
智慧指標是一個類，且這個類是個模板類，為了適應不同基本型別的需求，它在建構函式中傳入一個普通指標，將這個基本型別指標封裝為類物件指標，並在解構函式中釋放這個指標，刪除該指標指向的記憶體空間。因為一般使用時，智慧指標的類都是區域性物件，所以當函式（或程式）自動結束時會自動被釋放。

2、 常用的智慧指標：
STL一共提供了四種智慧指標：auto_ptr，unique_ptr，shared_ptr和weak_ptr

對於所有的智慧指標需要注意以下幾點：
1） 所有的智慧指標類都有一個explicit建構函式（阻止不應該允許的經過轉換建構函式進行的隱式轉換的發生，即不能在隱式轉換中使用），因此不能直接將指標轉換為只能指標物件，必須顯式呼叫，即

int* test=new int(2);
std::shared_ptr<int> p1=test;    //編譯報錯，無法從“int *”轉換                
                                  //為“std::tr1::shared_ptr<_Ty>”
                                  //因為建構函式被宣告為explicit，必須顯式呼叫
 

std::shared_ptr<int> p2(test);    //正確，顯式呼叫

2） 對全部三種智慧指標都應避免的一點：

string vacation("hello，world"); 
shared_ptr<string> pvac(&vacation); // 錯誤，No pvac過期時，程式將把delete運算子用於非堆記憶體，導致錯誤
shared_ptr<string> pvac1(new string("hello，world"));  //正確

下面簡要說明四種智慧指標的特點：

1）std::auto_ptr：屬於獨佔記憶體的方式，當p1=p2；時，p2的記憶體使用權轉移給p1（p1指向p2之前所指向的地址），p2成為空懸指標（指標地址為0），若之後使用p2，可以編譯通過，但執行時會出現記憶體訪問錯誤，不安全，會出現記憶體崩潰的問題。也因此不能被放入容器中（C++11已將其摒棄）

int* test=new int(2);
    std::auto_ptr<int> p1(new int(5));
    printf("p1:%d\n",p1);
    std::auto_ptr<int> p2(test);
    std::auto_ptr<int> p3=p1;    //不報編譯錯誤
    printf("p3:%d\n",p3);
    printf("p1:%d\n",p1);
    //std::auto_ptr<int> p4(p2);   //執行時報訪問錯誤
    //printf("%d\n",*p1);   //報訪問錯誤，因為p1將記憶體管理權轉移給p3了，p1懸空
    printf("%d\n",*p2);

2）C++引入的unique_ptr，也屬於獨享記憶體所有權，但優於auto_ptr，拷貝建構函式和賦值函式只有宣告沒有定義，且為私有函式，不能使用。直接賦值會編譯出錯。需要賦值的時候用std::move

std::unique_ptr<int> p5(new int(8));
    std::unique_ptr<int> p6(test);
    printf("%d\n",*p5);
    printf("%d\n",*p6);
    //std::unique_ptr<int> p7(p5);   //編譯報錯，庫內為private成員，且只宣告，未定義
    //std::unique_ptr<int> p8=p6;    //編譯報錯，庫內為private成員，且只宣告，未定義
    //printf("%d\n",*p7);
    //printf("%d\n",*p8);
    std::unique_ptr<int> p9=unique_ptr<int>(test);
    printf("%d\n",*p9);
    printf("p9:%d\n",p9);
    p6=std::move(p9);
    printf("p6:%d\n",p6);
    printf("p9:%d\n",p9);
    //printf("%d\n",*p6);    //記憶體訪問出錯，因為p6轉移了記憶體所有權

3）shared_ptr（boost、C++11）屬於共享記憶體，內部有引用計數機制（實現方式有兩種，一種是輔助類，一種是控制代碼類），對一個記憶體物件進行引用計數，當刪除其中一個指向該記憶體的指標時，引用計數減1，但並不會釋放該記憶體物件，只有當該記憶體物件的引用計數減為0時，才會釋放該塊記憶體，避免了指標空懸、記憶體訪問錯誤的情況。

std::shared_ptr<int> p10(new int(10));
    std::shared_ptr<int> p11(test);
    printf("%d\n",*p10);
    printf("%d\n",*p11);
    printf("p11->use_count:%d\n",p11.use_count());
    std::shared_ptr<int> p12(p10);   //編譯正常
    std::shared_ptr<int> p13=p11;    //編譯正常
    //std::weak_ptr<int> p13=p11;    //編譯正常
    printf("p11->use_count:%d\n",p11.use_count());
    printf("p13->use_count:%d\n",p13.use_count());
    printf("p11:%d\n",p11);
    printf("p13:%d\n",p13);
    //p11=p13;    //編譯正常
    printf("p11->use_count:%d\n",p11.use_count());
    printf("p13->use_count:%d\n",p13.use_count());
    printf("p11:%d\n",p11);
    printf("p13:%d\n",p13);
    //std::shared_ptr<int> p13=test;    //編譯報錯，無法從“int *”轉換為“std::tr1::shared_ptr<_Ty>”，因為建構函式被宣告為explicit，必須顯式呼叫
    printf("%d\n",*p11);
    printf("%d\n",*p12);
    //printf("%d\n",*p13);
    std::shared_ptr<int> p14=std::move(p10);
    printf("%d\n",*p14);
    p10 = p14;
    printf("%d\n",*p10);    //記憶體訪問出錯，因為p10轉移了記憶體所有權
    string vacation("I wandered lonely as a cloud.");
    shared_ptr<string> pvac(&vacation);   // No
    cout<<*pvac;

4）weak_ptr(boost、C++11)為shared_ptr設計，弱引用。只對shared_ptr進行引用，但不改變其計數；所以，當被引用的shared_ptr失效後，相應的weak_ptr也會失效。測試程式碼如下：

std::shared_ptr<int> p10(new int(10));
    std::shared_ptr<int> p11(test);
    printf("%d\n",*p10);
    printf("%d\n",*p11);
    printf("p11->use_count:%d\n",p11.use_count());
    std::shared_ptr<int> p12(p10);   //編譯正常
    //std::shared_ptr<int> p13=p11;    //編譯正常
    std::weak_ptr<int> p13=p11;    //編譯正常
    printf("p11->use_count:%d\n",p11.use_count());
    printf("p13->use_count:%d\n",p13.use_count());
    printf("p11:%d\n",p11);
    printf("p13:%d\n",p13);
    //p11=p13;    //編譯正常
    printf("p11->use_count:%d\n",p11.use_count());
    printf("p13->use_count:%d\n",p13.use_count());
    printf("p11:%d\n",p11);
    printf("p13:%d\n",p13);
    //std::shared_ptr<int> p13=test;    //編譯報錯，無法從“int *”轉換為“std::tr1::shared_ptr<_Ty>”，因為建構函式被宣告為explicit，必須顯式呼叫
    printf("%d\n",*p11);
    printf("%d\n",*p12);
    //printf("%d\n",*p13);
    std::shared_ptr<int> p14=std::move(p10);
    printf("%d\n",*p14);
    p10 = p14;
    printf("%d\n",*p10);    //記憶體訪問出錯，因為p10轉移了記憶體所有權
    string vacation("I wandered lonely as a cloud.");
    shared_ptr<string> pvac(&vacation);   // No
    cout<<*pvac;

看起來weak_ptr沒有什麼實質的作用，但實際上weak_ptr 主要用在軟體架構設計中，可以在基類（此處的基類並非抽象基類，而是指繼承於抽象基類的虛基類）中定義一個 boost::weak_ptr，用於指向子類的boost::shared_ptr，這樣基類僅僅觀察自己的 boost::weak_ptr 是否為空就知道子類有沒對自己賦值了，而不用影響子類 boost::shared_ptr 的引用計數，用以降低複雜度，更好的管理物件

3、 智慧指標的實現
這裡採用上文提到的輔助類的方式，具體程式碼如下：

//輔助類，用來引用計數
template<class friendclass,class T>
class U_ptr    
{
    friend friendclass;
    T *_p;
    int use_count;
    U_ptr(T *p):_p(p),use_count(1)
    {
        cout<<"U_ptr constructor called!"<<endl;
    }
    ~U_ptr()
    {
        if(use_count==0)
            delete _p;
        cout<<"U_ptr destructor has called!"<<endl;
    }
};

template<class T>
class smartpointer
{
private:
    U_ptr<smartpointer,T>* _ptr;
public:
    smartpointer(T* ptr):_ptr(new U_ptr<smartpointer,T>(ptr))  //建構函式
    {
        cout<<"smartpointer constructor called!"<<endl;
    }
    T& operator *()    //過載*運算子
    {
        return *(_ptr->_p);
    }
    smartpointer& operator=(const smartpointer &sptr)   //過載=運算子
    {
        ++(sptr._ptr->use_count);      //在減少左運算元的使用計數之前使rhs的使用計數加1，是為了防止自身賦值
        if(--_ptr->use_count==0)
            delete _ptr;
        _ptr=sptr._ptr;
        return *this;
    }
    smartpointer(const smartpointer &sptr):_ptr(sptr._ptr)   //拷貝建構函式
    {
        ++_ptr->use_count;
        cout<<"smartpointer copy constructor called!"<<endl;
    }
    int use_count()   //獲取引用計數值
    {
        return _ptr->use_count;
    }
    T* get_ptr()    //獲取指標地址
    {
        return _ptr->_p;
    }
    ~smartpointer()   //解構函式，計數為0時才釋放指標指向的記憶體
    {
        cout<<_ptr->_p<<" smartpointer deconstructor called!"<<endl;
        cout<<"before destruction use_count is="<<use_count()<<endl;
        if(--_ptr->use_count==0)
            delete _ptr;
    }
};
int test()
{
    smartpointer<int> p1(new int(8));//a should only be use to construct once  
    cout<<"p1.use_count="<<p1.use_count()<<endl;
    cout<<"p1="<<p1.get_ptr()<<endl;
    smartpointer<int> p2(p1);  
    cout<<"p1.use_count="<<p1.use_count()<<endl;
    cout<<"p2.use_count="<<p2.use_count()<<endl;
    cout<<"p1="<<p1.get_ptr()<<endl;
    cout<<"p2="<<p2.get_ptr()<<endl;
    smartpointer<int> p3(p1); 
    cout<<"p1.use_count="<<p1.use_count()<<endl;
    cout<<"p3.use_count="<<p3.use_count()<<endl;
    cout<<"p1="<<p1.get_ptr()<<endl;
    cout<<"p3="<<p3.get_ptr()<<endl;
    smartpointer<int> p4(p3);
    cout<<"p3.use_count="<<p3.use_count()<<endl;
    cout<<"p4.use_count="<<p4.use_count()<<endl;
    cout<<"p3="<<p3.get_ptr()<<endl;
    cout<<"p4="<<p4.get_ptr()<<endl;
    p4 = p4; 
    cout<<"p4.use_count="<<p4.use_count()<<endl;
    p4 = p3;  
    cout<<"p4.use_count="<<p4.use_count()<<endl;
    cout<<"p3.use_count="<<p3.use_count()<<endl;
    cout<<"p4="<<p4.get_ptr()<<endl;
    cout<<"p3="<<p3.get_ptr()<<endl;
    return 0;
}
int main(){
    test(); 
    return 0;
}

執行結果如下：

與實際應用STL中的智慧指標結果相近