unique_ptr(唯一性智能指针)

unique_ptr(唯一性智能指针)

不允许拿一个对象初始化另一个对象

删除了拷贝构造,有移动构造。

template<class _Ty>
class my_unique_ptr
{
private:
	_Ty* Ptr;
	my_unique_ptr(const my_unique_ptr&)=delete;
	my_unique_ptr& operator=(const my_unique_ptr&)=delet;
public:
	typedef _Ty* pointer;
	typedef _Ty element_type;
public:
	my_unique_ptr(my_unique_ptr&& _Y)
	{
		_Ptr=Y.Ptr;
		_Y.ptr=NULL;
	}
	my_unique_ptr& opetator=(my_unique_ptr&& _Y)
	{
		if(this=&_Y)return *this;
		delete _Ptr;
		_Ptr=Y.Ptr;
		_Y.ptr=NULL;
		return *this;
	}
	my_unique_ptr(_Ty*p=NULL):_Ptr(p){}
	~my_unique_ptr(){delete _Ptr;}
}
struct delete_object
{
	void operator()(Object* op)
	{
		if(op==NULL)return;
		delete op;
	}
}
struct delete_ar_object
{
	void operator()(Object* op)
	{
		if(op==NULL)return;
		felete[]op;
	}
}//两个模板函数，一个是对单个函数删除的函数，一个是对一组对象删除的函数

//两个删除对象，是一个对象用上面的，是一组对象调用下面的对象删除
template<class _Ty>
class MyDeletor<_Ty[]>
{
public:
	//MyDelete()=default;//默认构造函数
	MyDeletor(){}
	void operator()(_Ty* ptr)const
	{
		if(ptr!=nullptr)
		{
			delete[]ptr;
		}
	}
}
template<class _Ty>
class MyDeletor<_Ty>
{
public:
	MyDeleteor()=default;
	void operator()(_Ty* ptr)const
	{
		if(ptr!=nullptr)
		{
			delete ptr;
		}
	}
}


template<class _Ty,class _Dx=MyDeletor<_Ty>>//两个变量，一个对象，一个删除器
class my_unique_ptr
{

public:
	using pointer=_Ty*;
	using element_type=_Ty;
	using delete_type=Dx;
private:
	_Ty *_Ptr;//4
	_Dx myDeletor;//1       总共8字节
public:
	my_unique_ptr(const my_unique_ptr&)=delete;
	my_unique_ptr& operator=(const my_unique_ptr&)=delet;
	
	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!=NULL)
		{
			_my_Deletor(_Ptr);
		}
		_Ptr=_Y._Ptr;
		_Y._Ptr=nullptr;
		return *this;
	}
	
	_Dx & get_deleter()
	{
		return myDeleter;
	}
	
	const _Dx & get_deleter()const
	{
		return myDeleter;
	}
	
	_Ty& operator*()const
	{
		return *_Ptr;
	}
	pointer operator->()const
	{
		return &**this;
	}
	pointer get()const
	{
		return _Ptr;
	}
	operator bool()const
	{
		return _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);
		}
	}
	void swap(my_unique_ptr _Y)
	{
		std::swap(_Ptr,_Y._Ptr);
		std::swap(_myDeletor,_Y.myDeletor);
	}
	
	my_unique_ptr(pointer _P = nullptr) :_Ptr(_P){}
	~my_unique_ptr()
	{
		if(_Ptr!=nullptr)
		{
			_myDeletor(_Ptr);
			_Ptr=nullptr;
		}
	}
}

//可变模板参数类型
template<class ..._Ty>
void fun(_Ty ... arg)
{
	
}
//想给几个参数都可以系统会自己转换 c11

my_unique_ptr<Object> fun()//不能以引用返回
{
	my_unique_ptr<Object> opa(new Object(10));
	return opa;//这里传的是临时变量，将临时量的Object传给op1
}

my_unique_ptr<Object>& fun()
{
	return my_unique_ptr<Object>(new Object(10));//这里传的是创建了一个临时对象，变量里面的Object对象传给op1，临时对象先析构了，Object最后跟着op1一起结束
}
int main()
{
	my_unique_ptr<Object> op1;
	op1=fun();
	cout<<op1->Value()<<endl;
	
	return 0;
}