智能指针——auto_ptr

智能指针：自动的管理指针所指向动态资源的释放
首先我们先来看一下这个最古老的智能指针auto_ptr
但是他存在管理权转移的问题
这是一个最基本的auto_ptr

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

    //拷贝构造
    //管理权转移
    //ap1(ap)
    Autu_ptr(Autu_ptr<T>  &ap)
    {
        _ptr = ap._ptr;
        ap._ptr = NULL;
    }

    Autu_ptr<T> &operator=(Autu_ptr<T> &ap)
    {
        if (this != ap)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }

    ~Autu_ptr()
    {
        if (_ptr)
        {
            printf("delete %p\n", _ptr);
            delete _ptr;
        }
    }
    T& operator*()
    {
        return *_ptr;
    }

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

private:
    T *_ptr;
};


void AutoTest()
{
    Autu_ptr<int> ap(new int(1));
}

它的拷贝构造和赋值运算符的重载都是将ap._ptr直接赋值给_ptr,存在管理权转移的问题。而且当你再去访问ap._ptr的时候已经访问不到了

改进

template <class T>
class Autu_ptr
{
public:
    Autu_ptr(T *ptr)
    :_ptr(ptr),
    _owner(true)//当独占资源时，为true
    {}

    ~Autu_ptr()
    {
        if (_ptr && _owner)//当独占资源的时候直接释放指针
        {
            delete _ptr;
            _ptr = NULL;
        }
    }

    //ap1(ap)
    Autu_ptr&(Autu_ptr<T> &ap)
    {
        _ptr = ap._ptr;
        _owner = true;
        ap._owner = false;

    }

    //ap = ap1
    Autu_ptr<T>& operator=(Autu_ptr<T>& ap)template<class T>
    {
        if (this != &ap)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }

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

protected:
    T *_ptr;
    bool _owner;
};

但是也会存在野指针的问题