智能指针

一.智能指针
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;
};