智能指针-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
unique_ptr独有对象所有权-----只有我才能使用该资源，资源唯一性
拷贝构造函数=delete；
赋值语句=delete；
右值赋值语句可以使用
移动构造可以使用
2.特点
不支持普通的拷贝和赋值操作，但却提供了一种移动机制将指针所有权从一个unique_ptr转移给另一个unique_ptr---用std::move()函数
std::unique_ptr
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
template
5.源码
//辅助类--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);
}
};
template
my_unique_ptr<_Ty>my_make_unique(_Type&&..._Arys)
{
return my_unique_ptr<_Ty>(new _Ty(arys...));
//编译时确定有几个参数
}