智能指针smartPtr的模拟实现与运用

智能指针的使用及原理

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。智能指针为RALL的实现
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：
1.不需要显式地释放资源。
2.采用这种方式，对象所需的资源在其生命期内始终保持有效。

auto_ptr

template<class T>
class auto_ptr
{
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}
	~auto_ptr()
	{
		if(_ptr)
		{
			cout << "delete->" << _ptr << endl;
			delete _ptr;
			_ptr = nullptr;
		}
	}
	auto_ptr( auto_ptr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = nullptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

缺：赋值构造后原来的对象被置nullptr，无法读取资源

unique_ptr

template <class T>
class unique_ptr
{
public:
	unique_ptr(T* ptr)
		:_ptr(ptr)
	{}
	~unique_ptr()
	{
		
			cout << "delete->" << _ptr << endl;
			delete _ptr;
		
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	unique_ptr(const unique_ptr<T>& ptr) = delete;
	unique_ptr<T>& operator=(unique_ptr<T>& ptr) = delete;
private:
	T* _ptr;
};

优：直接强制让编译器不生成赋值和=
缺：无法赋值和=

share_ptr

template <class T>
class share_ptr
{
public:
	share_ptr(T* ptr=nullptr)
		:_ptr(ptr)
		, _cnt(new int 1)
	{}
	template <class D>
	share_ptr(T* ptr,D del)
		:_ptr(ptr)
		,_cnt(new int 1)
		,_del(del)
	{}
	~shared_ptr()
	{
		release();
	}
	void release()
	{
		if (--(*_cnt) == 0)
		{
			_del(_ptr);
			delete _cnt;
		}
	}
	share_ptr(const share_ptr<T>& it)
		:_ptr(it._ptr)
		:_cnt(it._cnt)
	{
		++(*it._cnt);
	}
	share_ptr<T>& operator=(share_ptr<T>& it)
	{
		if (_ptr != it._ptr)
		{
			release();
			_ptr = it._ptr;				
			_cnt = it._cnt;
			++(*it._cnt);  
		}
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	int use_count()const
	{
		return *_cnt;
	}
	T* get()const
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _cnt;
	function<void(T*)> _del = [](T* ptr) { delete ptr; };
};

优：通过增加一个成员去判断什么时候去delete内存
缺：无法完成循环引用(可增加一个weak_ptr去配合完成)

weak_ptr

template <class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}
	weak_ptr(const share_ptr<T>& sp)
		:_ptr(sp.get())
	{}
	weak_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

	// 像指针一样
	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

无法自己使用，为配合share_ptr解决循环引用所使用