智能指针-auto_ptr

智能指针：

//不在智能指针中研究const

1.为什么需要智能指针？

裸指针：int *ip=NULL；//无法判断指的是一个对象还是一组对象

直接定义的指针是裸指针

class shape{};

std::vectorshape;

int *ip;//野指针

Object*op=NULL；//空指针

Destory（Object*ip）{delete ip； }//失效指针，悬空指针

2.智能指针分类

unique_ptr拥有独有对象所有权

shared_ptr拥有共享对象所有权

weak_ptrstd::shared_ptr所管理对象的弱作用

auto_ptr严格对象所有权

3.c++11中弃用，c++17中移除

/auto_ptr 不使用的原因： //拷贝构造函数 意义不明确

//浅拷贝：会对一个对象造成析构两次

//my_auto_ptr(cosnt my_auto_ptr &op):Owns（op.Owns),Ptr(op.Ptr){}

// //my_auto_ptr(cosnt my_auto_ptr &op):Owns（op.Owns),Ptr(op.release()){} //

STL    vector，list中不用auto_ptr

SRL   boost

4.auto_ptr源码

template 
class my_auto_ptr
{
private:
    bool _Owns;
    _Ty* Ptr;
public:
    explicit my_auto_ptr(_Ty* p = NULL) :_Owns(p != NULL), _Ptr(p) {}
    ~my_auto_ptr()
    {
        if (_Owns) { delete _Ptr; }
        _Owns = false;
        _Ptr = NULL;
    }
    _Ty* get()const { return _Ptr; }


    _Ty& operator*()const
    {
        return *(get());
    }
    _Ty* operator->()const
    {
        return &**this;//return get();
    }
    void reset(_Ty* p)
    {
        if (_Owns)
        {
            delete _Ptr;
        }
        _Ptr = p;
    }
};







//辅助类--default——delete
//删除器
template
class MyDeletor
{
public:
    MyDeletor(){}
    void operator()(_Ty* ptr) const 
    {
        if(ptr!=nullptr)
            delete ptr;
    }
};

template
class MyDeletor<_Ty[]>
{
public:
    MyDeletor() = default;//明确的告知有构造函数
    void operator()(_Ty* p tr) const
    {
        if (ptr != nullptr)
            delete[] ptr;
    }
};


//class unique_ptr
template>
class my_unique_ptr
{
public:
    //old
    //typedef _Ty* pointer;
    //typedef _Ty element_type;
    //typedef _Dx delete_type;
    //  
    //c11  new,对已有的类型进行重命名
    using pointer = _Ty*;
    using element_type = _Ty;
    using delete_type = _Dx;//删除器

private:
    _Ty* _Ptr;//指针
    _Dx _myDeletor;//删除器
public:

    my_unique_ptr(const my_unique_ptr&) = delete;
    my_unique_ptr& operator=(const my_unique_ptr&) = delete;

    my_unique_ptr(my_unique_ptr&& _Y)
    {
        _Ptr = _Y._Ptr;
        _Y._Ptr = nullptr;
    }
    my_unique_ptr& operator=(my_unique_ptr&& _Y)
    {
        if (this == &_Y)    return *this;
        reset(_Y.release());
        //if(_Ptr!=nullptr){_myDeletor(_Ptr):}
        //_Ptr=_Y._Ptr;
        //_Y._Ptr=nullptr;
        return *this;
    }

    const _Dx & get_deleter()const
    {
        return myDeletor;
    }
    _Dx& get_deleter()
    {
        return myDeletor;
    }
    _Ty& operator*()const
    {
        return *_Ptr;
    }
    pointer operator->()const
    {
        return &**this;//_Ptr;
    }
    pointer get()const
    {
        return _Ptr;
    }
    //强转成bool类型
    operator bool()const
    {
        return _Ptr != nullptr;
    }

    my_unique_ptr(pointer _P=nullptr):_Ptr(_P){}
    ~my_unique_ptr()
    {
        if (_Ptr != nullptr)
        {
            _myDeletor(_Ptr);//调动对象的仿函数，——myDeletor对象的仿函数
            _Ptr = nullptr;
        }
    }

    pointer release()
    {
        _Ty* old = _Ptr;
        _Ptr = nullptr;
        return old;
    }
    void reset(pointer _P = nullptr)
    {
        pointer old = _Ptr;
        _Ptr = _P;
        if (old != nullptr)
        {
            _myDeletor(old);
            get_deleter()(old);
        }
    }
    void swap(my_unique_ptr _Y)
    {
        std::swap(_Ptr, _Y._Ptr);
        std::swap(_myDeletor, _Y.myDeletor);
    }
};

5.注意

作为函数的参数按值传递一定要避免 

auto_ptr

不能指向数组

不能共享所有权

不能通过复制操作来初始化

不能放入容器中使用

不能作为容器成员