C++ | auto_ptr与unique_ptr

---

前言

浅谈智能指针

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、RAII

二、裸指针

1.裸指针是什么

由类型直接定义的指针。比如：

2.裸指针所带来的问题、

1.难以区分指向的是单个对象还是一个数组;
2.使用完指针之后无法判断是否应该销毁指针， 因为无法判断指针是否"拥有” 指向的对象;
3.在已经确定需要销毁指针的情况下，也无法确定是用delete关键字删除，还是有其他特殊的销毁机制,例如通过将指针传入某个特定的销毁函数来销毁指针;
4.即便已经确定了销毁指针的方法，由于1的原因，仍然无法确定到底是用delete(销毁单个对象)还是delete[(销毁一个数组);
5.假设上述的问题都解决了，也很难保证在代码的所有路径中(分支结构,异常导致的跳转)，有且仅有一次销毁指针操作;任何一条路径遗漏都可能导致内存泄露，而销毁多次则会导致未定义行为;
6.理论上没有方法来分辨一个指针是否处于悬挂状态;

无法判断裸指针指向的是一个对象还是一组对象，同样析构时亦无法判断是用delete还是delete[]

三、智能指针

1.智能指针的种类

其中auto_ptr已经被移除，主要原因在于拷贝构造函数意义不明确。同时析构函数也不能判断是析构一个对象还是一组对象。
拷贝构造函数第一种写法：

这样导致两个对象拥有同样的资源，在对象析构时会对同一块空间进行二次释放造成程序崩溃。
拷贝构造函数的第二种写法：

这也会导致在传参时，实参失去对原有资源的掌握权，在后续操作时出现问题。

2.unique_ptr

代码如下（示例）：

#include<iostream>
using namespace std;

//辅助删除器
template <typename _Ty>
class Mydeletor
{
public:
	Mydeletor() = default;
	void operator()(_Ty* op)const
	{
		if (op == NULL)  return;
		delete op;
		op = NULL;
	}
};

template <typename _Ty>//delete Array
class Mydeletor<_Ty[]>
{
public:
	Mydeletor() = default;
	void operator()(_Ty* op)const
	{
		if (op == NULL)  return;
		delete []op;
		op = NULL;
	}
};

//unique_ptr
template<typename _Ty,typename _Dx=Mydeletor<_Ty>>
class my_unique_ptr
{
public:
	using pointer = _Ty*;
	using element_type = _Ty;
	using delete_type = _Dx;
public:
	my_unique_ptr(_Ty* p = NULL) :_Ptr(p) 
	{
		cout << "Create my_unique_ptr" << this << endl;
	}
	my_unique_ptr(const my_unique_ptr&) = delete;
	my_unique_ptr& operator=(const my_unique_ptr&) = delete;
	my_unique_ptr(const my_unique_ptr&& op)//移动构造
	{
		cout << "移动构造" << endl;
		_Ptr = op._Ptr;
		op._Ptr = NULL;	
		//_mydeletor = op._mydeletor;
		
	}
	template<typename _Uy>
	my_unique_ptr& operator=(_Uy* _p)
	{
		
		if (_Ptr == (_Ty*)_p)  return *this;
		if (_Ptr != NULL)
		{
			_mydeletor(_Ptr);
		}
		_Ptr = _p;
		cout << "1" << endl;
		return *this;
		
	}
	my_unique_ptr& operator=( my_unique_ptr&& op)//移动赋值
	{
		if (this == &op)  return *this;
		reset(op.release());//1 op.release交出_Ptr的拥有权
		                    //2 reset(op.release)是将this->_Ptr指向利用1中 返回的的对象 重建的对象
		//如果没有上边这一行代码，需要以下代码
		/*
		if (_Ptr != NULL)
		{
			_mydeletor(_Ptr);
		}
		_Ptr = op._Ptr;
		op._Ptr = NULL;
		*/
		cout << "移动赋值" << endl;
		return *this;
	}
	~my_unique_ptr()
	{
		if (_Ptr != NULL)
		{
			_mydeletor(_Ptr);
			_Ptr = NULL;
		}
		cout << "~my_unique_ptr" << this << endl;
	}
	_Dx& get_deleter()
	{
		return _mydeletor;
	}
	const _Dx& get_deleter()const
	{
		return _mydeletor;
	}
	operator bool()
	{
		return _Ptr != NULL;
	}
	_Ty&operator*()
	{
		return *(_Ptr);
	}
	_Ty* operator->()
	{
		return &**this;
	}
	void reset(_Ty* op = NULL)
	{
		if (_Ptr!=NULL)
		{
			_mydeletor(_Ptr);
		}
		_Ptr = op;
	}
	pointer release()
	{
		_Ty* old = _Ptr;
		_Ptr = NULL;
		return old;
	}
	void swap(my_unique_ptr op)
	{
		std::swap(_Ptr, op._Ptr);
		std::swap(_mydeletor, op._mydeletor);
	}
private:
	_Ty* _Ptr;
	_Dx _mydeletor;
};

---

总结

unique_ptr删除了拷贝构造和赋值运算，加入了移动构造和移动赋值，解决了资源归属的问题，同时拥有自己的默认删除器，可以通过其来判断是调用删除一个对象的析构函数还是调用删除一组对象的析构函数。