智能指針

一.智能指針
1.定義
所謂智能指針就是智能/自動化的管理指針所指向的動態資源的釋放
2.智能指針發展歷史

3.auto_ptr/scoped_ptr/shared_pr/weak_ptr的設計思想、缺陷

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

    ~AutoPtr()
    {
        cout << "~AutoPtr()" << endl;
        delete _ptr;
    }
    AutoPtr(AutoPtr<T>& ap)//拷貝構造函數 
        :_ptr(ap._ptr)
    {
        ap._ptr = NULL;//管理權轉移給_ptr
    }
    AutoPtr<T>& operator=(AutoPtr<T>& ap)
    {
        if (this != &ap)
        {
            if (_ptr)
                delete _ptr;//不爲空釋放
            _ptr = ap._ptr;
            ap._ptr = NULL;//管理權轉移
        }
        return this;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
private:
    T* _ptr;
};

一般運行時不會出現問題，但是auto_ptr的管理權會轉移，利用ap1進行賦值或者拷貝構造給ap2時，ap1置空，此時再訪問ap1程序會崩潰

scoped_ptr:
爲了解決auto_ptr賦值和拷貝構造所出現的對操作舊指針問題，我們引入了scoped_ptr.scoped_ptr的功能就是防拷貝。當拷貝或賦值時直接就會報錯

template<class T>
class ScopedPtr
{
public:
    ScopedPtr(T* ptr)
        :_ptr
    {}
    ~ScopedPtr()
    {
        if(_ptr)
        {
            delete _ptr;
            cout << "~ScopedPtr" << endl;
        }
    }

    T& ScopedPtr*()
    {
        return *_ptr;
    }
    T* ScopedPtr->()
    {
        return _ptr;
    }
private:
    ScopedPtr<T>(const ScopedPtr<T>& sp);
    ScopedPtr<T>& operator = (ScopedPtr<T>& sp);
    T* _ptr;
};

shared_ptr
當我們需要使用拷貝功能時 這時就引入了shared_ptr
設計思想：引用計數，多個指針指向同一塊空間

template<class T>
class SharedPtr
{
public:
    SharedPtr(T* ptr = NULL)//構造函數，添加引用計數
        :_ptr(ptr)
        , _refCount(new int(1))
    {}
    SharedPtr<T>(SharedPtr<T>& sp)
        : _ptr(sp._ptr)
        , _refCount(sp._refCount)
    {
        ++(*_refCount);
    }
    /*SharedPtr<T>& operator = (SharedPtr<T>& sp)
    {
        if (_ptr != sp._ptr)
        {
            if (--(*_refCount) = 0)
            {
                delete _ptr;
                deletd _refCount;
            }
            _ptr = sp._ptr;
            _refCount = sp._refCount;
            (*_refCount)++;
        }
        return *this;
    }*/
    SharedPtr<T>& operator = (SharedPtr<T>& sp)
    {
        swap(_ptr, sp._ptr);
        swap(_refCount, sp._refCount);
        return *this;
    }
    ~SharedPtr()
    {
        if (--(*_refCount) == 0)
        {
            delete _ptr;
            delete _refCount;
        }
    }
    T* operator ->()
    {
        return _ptr;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* GetPtr()
    {
        return _ptr;
    }
    int GetrefCount()
    {
        return *_refCount;
    }
private:
    T* _ptr;
    int* _refCount;
};

這裏會出現循環引用的問題。這時我們引入weak_ptr

template<class T>
class WeakPtr()
{
public:
    WeakPtr()
        :_ptr(NULL)
    {}
    WeakPtr(const SharedPtr<T>& sp)
        :_ptr(sp._ptr)
    {}
    T& operator*()
    {
        return *_ptr;
    }
    T& operator->()
    {
        return _ptr;
    }
private:
    T* _ptr;
};