智能指针-unique_ptr

目录

1.创建unique_ptr

2.特点

3.unique_ptr的场景

4.写模板时，写了两种，一份是对单个对象，一个是对一组对象给出的方案

 5.源码

---

1.创建unique_ptr

如何创建unique_ptr unique_ptr不像shared_ptr一样拥有标准库函数make_shared来创建一个shared_ptr实例。 要想创建一个unique_ptr，我们需要将一个new操作符返回的指针传递给unique_ptr的构造函数。

int   main(){ //创建一个unique_ptr实例 unique_ptr<int>pInt(newint(5)); cout<<*pInt; }

unique_ptr独有对象所有权-----只有我才能使用该资源，资源唯一性

拷贝构造函数=delete；

赋值语句=delete；

右值赋值语句可以使用

移动构造可以使用

2.特点

不支持普通的拷贝和赋值操作，但却提供了一种移动机制将指针所有权从一个unique_ptr转移给另一个unique_ptr---用std::move()函数

std::unique_ptr<Object> pobja(new Object(100)); //移动构造---将poja的资源转移到b中 std::unique_ptr<Object> pobjb(std::move(pobja)); // std::unique_ptr<Object> pobjc(new Object(20)); pobja = std::move(pobjc); //底层实现-- pobja = (std::unique_ptr<Object>&&)(pobjc); //移动赋值

3.unique_ptr的场景

(1).语义简单，即当你不确定使用的指针是不是被分享所有权的时候，默认选unique_ptr独占式所有权，当确定要被
分享的时候可以转换成shared_ptr；
(2).unique_ptr效率比shared_ptr高，不需要维护引用计数和背后的控制块;
(3).unique_ptr用起来更顺畅，选择性更多，可以转换成shared_ptr和通过get和release定制化智能指针（custom
smartpointer）。
(4).在工厂模式中作为对象的返回。

//右值引用
my_unique_ptr(my_unique_ptr&& _Y)
{
    _Ptr = _Y._Ptr;
    _Y.Ptr = NULL;
}
//移动赋值
my_unique_ptr&operator=(my_unique_ptr&& _Y)
{
    if (this == &_Y)return *this;
    delete _Ptr;//将自己的资源释放掉
    _Ptr = _Y._Ptr;
    _Y.Ptr = NULL;
    return *this;
}

4.写模板时，写了两种，一份是对单个对象，一个是对一组对象给出的方案

template <class T, class D> class my_unique_ptr { public: my_unique_ptr() { cout << "T,D" << endl; } };

template <class T, class D> class my_unique_ptr<T[], D> { public: my_unique_ptr() { cout << "T[],D" << endl; } };

 5.源码

//辅助类--default——delete
//删除器

//默认删除器，只删除一个对象
template<class _Ty>
class MyDeletor
{
public:
    MyDeletor(){}
    void operator()(_Ty* ptr) const 
    {
        if(ptr!=nullptr)
            delete ptr;
    }
};

//特化版删除器，删除一组对象

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

//class unique_ptr
template<class _Ty,class _Dx=MyDeletor<_Ty>>
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);
    }
};

template<class _Ty,class ..._Type>
my_unique_ptr<_Ty>my_make_unique(_Type&&..._Arys)
{
    return my_unique_ptr<_Ty>(new _Ty(arys...));
    //编译时确定有几个参数
}