在介紹智慧指標之前我們先看以下程式碼：

void FunTest()
{
    int *p = new int[10];
    FILE* pFile = fopen( "1.txt", "w" );
    if (pFile == NULL)
    {
        return;
    }
    // DoSomethint();
    if (p != NULL)
    {
        delete[] p;
        p = NULL;
    }
}

在該程式碼中，我們注意了對指標的釋放卻忽略了對檔案指標的關閉。C++中的動態記憶體需要使用者自己來維護，動態開闢的空間，在出函式作用域或者程式正常退出前必須釋放掉，否則會造成記憶體洩露，有時我們已經非常謹慎了，然防不勝防。

智慧指標(RAII)的存在一開始就是為了解決資源分配即初始化，其解決方案是定義一個類來封裝資源的分配和釋放，在建構函式完成資源的分配和初始化，在解構函式完成資源的清理，可以保證資源的正確初始化和釋放。

所以有了第一代Auto_Ptr

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr = NULL)
        :_ptr(ptr)
    {}

    AutoPtr(AutoPtr<T>& s)
        :_ptr(s._ptr)
    {
        s._ptr = NULL;
        //經過賦值拷貝，原本的智慧指標s中_ptr 已經指向空
 

    }

    AutoPtr<T>& operator=(AutoPtr<T>& s)
    {
        if (this != &s)
        {
            if (_ptr)
            {
                delete _ptr;    
            }   
            _ptr = s._ptr;
            s._ptr = NULL;
            //經過賦值運算子後同樣被置空
        }
        return
 
 *this;
    }

    T* operator->()const
    {
        return _ptr;
    }

    T& operator*()const
    {
        return *_ptr;
    }

    ~AutoPtr()
    {
        if (_ptr)
        {
            delete _ptr;
        }
    }
private:
    T* _ptr;
};


void Funtest1(AutoPtr<char> p)
{}

void Funtest2(AutoPtr<char>& p)
{}


int main()
{
    AutoPtr<char> p1(new char);
    AutoPtr<char> p2(p1);

    //AutoPtr<char> p4(p3);  出錯，不能通過編譯，原因在拷貝建構函式中更改了具有常性的 p3


    //Funtest1(p2);   同理，以傳值形式作為函式形參，也要經過拷貝建構函式形成臨時變數p，同理賦值崩潰

    Funtest2(p2);   //以引用的方式傳遞沒有問題
    *p2 = '1';
    return 0;
}

由此可見一代Auto_Ptr的缺點都有以下幾點：
1：在Auto_Ptr中經過資源轉移後，p1不能再訪問空間
2：以值傳遞的形式作為函式引數後，一旦呼叫函式，該智慧指標在原函式中也不能訪問空間
3：const物件不能構造同類型物件

針對第一代Auto_Ptr的問題，於是乎有了第二代Auto_Ptr的產生實際上我們是使用一個bool 型別的 資料成員來表明該智慧指標是否具有被析構的能力

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr = NULL)
           :_ptr(ptr)
           , type(false)
    {
        if (_ptr)
            type = true;
    }

    AutoPtr(const AutoPtr<T>& s)
        :_ptr(s._ptr)
        , type(s.type)
    {
        s.type = false;
    }

//拷貝建構函式中，將s物件具有析構的能力 type賦給新物件，而s.type賦值為false，說明不具有析構能力
    AutoPtr<T>& operator=(const AutoPtr<T>& s)
    {
        if (this != &s)
        {
            if (_ptr && type)
            {
                delete _ptr;
            }
            _ptr = s._ptr;
            type = s.type;
            s.type = false;
        }
        return *this;
    }

    T& operator*()const
    {
        return *_ptr;
    }
 //解構函式中，我們將 type 為true的智慧指標進行析構，從而避開了對同一空間釋放多次的問題
    ~AutoPtr()
    {
        if (_ptr && type)
        {
            delete _ptr;
            _ptr = NULL;
            type = false;
        }
    }

private:
    T* _ptr;
    mutable bool type;
    //在成員函式體內只改變了type的值，針對於const物件，我們加關鍵字mutable可以更改type的值
};

void Funtest1(AutoPtr<char> p)
{}

int main()
{
    AutoPtr<char> p1(new char);
    void Funtest1(p1);
    AutoPtr<char> p2(p1);
    AutoPtr<char> p3(new char);
    AutoPtr<char> p4(p3);
    Funtest1(p1);
    p1 = p3;
    *p3 ='1';
    return 0;
}

經過驗證，我們確定基於第一代的修改我們成功的引入了第二代,但是我們引入了一個野指標的問題，一旦對於野指標進行操作，很容易造成問題，

當我們用智慧指標管理一個無名的智慧指標物件時，編譯器會自動優化，呼叫系統的建構函式，如果我們想呼叫我們自己寫的建構函式，我們推匯出智慧指標的第三個版本

template<class T>
class autoptrref
{
public:
    autoptrref(T* ptr = NULL)
        :_ptr(ptr)
    {}
    T* _ptr;
};

template<class T>
class autoptr
{
public:
    //建構函式
    autoptr(T* ptr = NULL)
        :_ptr(ptr)
    {}

    //拷貝建構函式
    autoptr(autoptr<T>& ap)
        :_ptr(ap._ptr)
    {
        ap._ptr = NULL;//拷貝完後將ap._ptr置NULL
    }

    //賦值運算子的過載
    autoptr<int>& operator=(autoptr<T>& ap)
    {
        if (this != &ap)
        {
            if (_ptr != NULL)
            {
                delete _ptr;
            }
            _ptr = ap._ptr;
            ap._ptr = NULL;//賦值完後將ap._ptr置NULL
        }
        return *this;
    }

    //解決辦法

    //過載autoptrref()
    operator autoptrref<T>()//將autoptr<T>轉化為autoptrref<T>
    {
        autoptrref<T> temp(_ptr);
        _ptr = NULL;
        return temp;
    }

    //再過載一個拷貝建構函式
    autoptr(const autoptrref<T>& apr)
        :_ptr(apr._ptr)
    {}

    ~autoptr()//解構函式
    {
        if (_ptr != NULL)
        {
            delete _ptr;
        }
    }


    //*的過載
    T& operator*()const
    {
        return *_ptr;
    }

    //得到原生態指標
    T* Get()const
    {
        return _ptr;
    }

private:
    T* _ptr;
};
void funtest()
{
    autoptr<int> ap(autoptrref<int>(autoptr<int>(new int)));
    //用無名的智慧指標拷貝構造智慧指標ap,則不會呼叫我們編寫好得拷貝建構函式，而是呼叫系統自動合成個的拷貝建構函式
}    //原因是編譯器的自動優化，解決辦法：重新增加一個類autoptrref,將無名物件的型別轉化為autoptrref                                       

int main()
{
    funtest();
    return 0;
}