智能指針之 unique_ptr

　　對於動態申請的內存，C++語言為我們提供了new和delete運算符， 而沒有像java一樣，提供一個完整的GC機制，因此對於我們申請的動態內存，我們需要時刻記得釋放，且不能重復釋放，釋放后不能再去使用...  因此在使用時造成很多不便，且容易出現很多問題，一旦出問題就造成core dump，程序直接掛掉 ， 這個時候，智能指針的優勢就體現出來了，智能指針符合RAII原則，資源獲取就是初始化，在對象析構時，將資源進行釋放，對動態內存做到一個比較好的管理

　　unique_ptr 持有對對象的獨有權—兩個unique_ptr不能指向一個對象，不能進行復制操作只能進行移動操作

　　unique_ptr擁有所有auto_ptr的功能，且unique_ptr通過將復制構造和賦值操作符私有化，將對象的所有權獨有，很好的將auto_ptr的安全問題給規避掉了，unique_ptr的其他特點包括：1.提供刪除器釋放對象，允許用戶自定義刪除器 2.添加了對象數組的偏特化實現，new[]，delete[] 3.使用C++ 11的右值引用特性，實現所有權轉移 std::move()

　　本次實現，將unique_ptr的基本接口進行了實現，基本包括了unique_ptr的功能  （編譯平台：Linux centos 7.0　編譯器：gcc 4.8.5 )

　　使用std::unique_ptr時，需要#include <memory>頭文件，具體使用代碼如下（文件名：test_ptr.cpp）：

#include <memory>
#include <iostream>

using namespace std;

class Test
{
public:
    Test()
    {
        cout << "construct.." << endl;
    }
    
    ~Test()    
    {
        cout << "destruct.." << endl;
    }
};

void test()
{
    
}

int main()
{
    //auto_ptr
    Test* p = new Test(); 
    auto_ptr<Test> ap(p);
    
    //unique_ptr
    Test* p1 = new Test();
    unique_ptr<Test> up(new Test());
    unique_ptr<Test> up1(move(up));

    

    //unique_ptr<Test> up2 = up;
    
    unique_ptr<int> up3(new int(5));

    return 0;
}

　　具體實現代碼如下，沒有對動態對象數組及std::move()進行實現，動態對象數組實現代碼和這差不多，寫個模板偏特化即可，至於std::move()則和成員函數release()類似，轉移所有權（文件名：unique_ptr_implement.cpp）:

#include <iostream>
#include <assert.h>

using namespace std;

#define PTR_ASSERT(x) assert(x)

template<class T>
struct defalute_deleter
{
    void defalute_deleter_method()
    {
        cout << "deleter method..." << endl;
    }
    void operator()(T* ptr)
    {
        if(ptr != NULL)
        {
            cout << "default deleter....." << endl;
            delete ptr;
            ptr = NULL;
        }
    }
};

template<typename T, typename deleter = defalute_deleter<T> >
class unique_ptr
{
public:
    explicit unique_ptr(T* ptr = NULL);
    
    unique_ptr(T* ptr, deleter d);

    ~unique_ptr();

    T* get();

    void reset(T* ptr = NULL);

    deleter& getDeleter();

    T* release();

public:
    T& operator*();    
    
    T* operator->();

    operator bool() const;
    
private:
    unique_ptr(unique_ptr& up);

    unique_ptr& operator = (unique_ptr& up);
    
private:
    T* m_ptr;

    deleter m_deleter;
};

template<typename T, typename deleter>
unique_ptr<T, deleter>::unique_ptr(T* ptr /* = NULL */, deleter d)
{
    if(ptr != NULL)
    {
        m_ptr = ptr;
        m_deleter = d;
    }
}

template<typename T, typename deleter>
unique_ptr<T, deleter>::unique_ptr(T* ptr /* = NULL */)
{
    if(ptr != NULL)
    {
        m_ptr = ptr;
    }    
}

template<typename T, typename deleter>
unique_ptr<T, deleter>::~unique_ptr()
{
    if(m_ptr != NULL)
    {
        m_deleter(m_ptr);
        m_ptr = NULL;
    }
}

template<typename T, typename deleter>
T& unique_ptr<T, deleter>::operator*()
{
    PTR_ASSERT(m_ptr != NULL);

    return *m_ptr;
}

template<class T, class deleter>
T* unique_ptr<T, deleter>::operator->()
{
    PTR_ASSERT(m_ptr != NULL);

    return m_ptr;
}

template<typename T, typename deleter>
T* unique_ptr<T, deleter>::get()
{
    return m_ptr;
}

template<typename T, typename deleter>
void unique_ptr<T, deleter>::reset(T* ptr)
{
    T* old_ptr = m_ptr;
    m_ptr = ptr;

    if(old_ptr != NULL)
    {
        m_deleter(old_ptr);
        old_ptr = NULL;
    }
}

template<typename T, typename deleter>
deleter& unique_ptr<T, deleter>::getDeleter()
{
    return m_deleter;
}

template<typename T, typename deleter>
T* unique_ptr<T, deleter>::release()
{
    T* pTemp = m_ptr;
    m_ptr = NULL;

    return pTemp;    
}

template<typename T, typename deleter>
unique_ptr<T, deleter>::operator bool() const
{
    return m_ptr != NULL;
}


//Test class
class Test
{
public:
    Test()
    {
        cout << "construct.." << endl;
    }
    
    ~Test()    
    {
        cout << "destruct.." << endl;
    }

    void method()
    {
        cout << "welcome Test.." << endl;
    }
};

//custom deleter
template <class T>
struct custom_deleter
{
    void deleter_method()
    {
        cout << "custom deleter method..." << endl;
    }

    void operator()(T* ptr)
    {
        cout << "custom deleter... " << endl;
        delete ptr;
        ptr = NULL;
    }
};


int main()
{
    //default deleter
    cout << "=======default deleter====interface test begin: ========== " << endl;
    unique_ptr<Test> up(new Test());
    
    cout << "operator ->: " << endl;
    up->method();
    
    cout << "operator *: " << endl;
    (*up).method();

    cout << "operator bool: " << endl;
    if(up){ cout<< "obj is exit" << endl;}

    cout << "get: " << endl;
    up.get()->method();

    cout << "getDeleter: " << endl;
    defalute_deleter<Test> del = up.getDeleter();
    del.defalute_deleter_method();

    cout << "release: " << endl;
    unique_ptr<Test> up1(up.release());

    //if take this,  will die
    //(*up).method();

    cout << "reset: " << endl;
    up1.reset();

    //Custom deleter
    cout << "=======Custom deleter====interface test begin: ========== " << endl;
    custom_deleter<Test> d;
    unique_ptr<Test, custom_deleter<Test> > up_custom_dele(new Test(), d);
    
    cout << "operator ->: " << endl;
    up_custom_dele->method();
    
    cout << "operator *: " << endl;
    (*up_custom_dele).method();

    cout << "operator bool: " << endl;
    if(up_custom_dele){ cout<< "obj is exit" << endl;}

    cout << "get: " << endl;
    up_custom_dele.get()->method();

    cout << "getDeleter: " << endl;
    custom_deleter<Test> custom_del = up_custom_dele.getDeleter();
    custom_del.deleter_method();

    cout << "release: " << endl;
    unique_ptr<Test> up3(up_custom_dele.release());

    //if take this,  will die
    //(*up_custom_dele).method();

    cout << "reset: " << endl;
    up3.reset();
    

    return 0;
}

　　執行代碼，打印如下：

[root@localhost code]# g++ -o unique unique_ptr_implement.cpp 
[root@localhost code]# ./unique
=======default deleter====interface test begin: ========== 
construct..
operator ->: 
welcome Test..
operator *: 
welcome Test..
operator bool: 
obj is exit
get: 
welcome Test..
getDeleter: 
deleter method...
release: 
reset: 
default deleter.....
destruct..
=======Custom deleter====interface test begin: ========== 
construct..
operator ->: 
welcome Test..
operator *: 
welcome Test..
operator bool: 
obj is exit
get: 
welcome Test..
getDeleter: 
custom deleter method...
release: 
reset: 
default deleter.....
destruct..
[root@localhost code]# 

　　從實現結果可以看出，unique_ptr保證一個動態對象只有一個unique_ptr對象所擁有，unique_ptr對象之間無法copy和賦值，只能進行動態內存對象的轉移，轉移時，原有的unique_ptr對象將不再擁有動態內存的訪問權限，這樣可以保證動態內存使用的安全性。在實現中構造函數提供了兩個，一個使用默認刪除器，另一個則需要我們構造時傳入刪除器，這樣可以很好的進行資源自定義刪除。 對於多個指針對象指向同一個動態內存對象，unique_ptr不適用，需使用share_ptr