【C++】STL中shared_ptr仿写一

---

一、关于shared_ptr

定义于头文件

template< class T > class shared_ptr;
//(C++11 起) 

std::shared_ptr 是通过指针保持对象共享所有权的智能指针。多个 shared_ptr 对象可占有同一对象。
下列情况之一出现时销毁对象并解分配其内存：

• 最后剩下的占有对象的 shared_ptr 被销毁；
• 最后剩下的占有对象的 shared_ptr 被通过 operator= 或 reset() 赋值为另一指针。

---

二、shared_ptr对象内存结构

三、仿写代码

shared_ptr

#ifndef SHARED_PTR_H
#define SHARED_PTR_H
#include <iostream>
using namespace std;
namespace pzj
{
	//单个对象删除器
	template<class _Ty>
	class Deleter
	{
		Deleter() = default;
	public:
		void operator()(_Ty* p = NULL)const
		{
			if (p != NULL)
			{
				delete p;
			}
		}
	};
	//一组对象删除器
	template<class _Ty>
	class Deleter<_Ty[]>
	{
		Deleter() = default;
	public:
		void operator()(_Ty* p = NULL)const
		{
			if (p != NULL)
			{
				delete[] p;
			}
		}
	};

	//引用计数类
	template<class _Ty>
	class Rfc
	{
	private:
		_Ty* _mptr;		//存放被管理对象的地址
		size_t _count;	//管理者的个数
	public:
		Rfc(_Ty* p = NULL) : _mptr(p), _count(p != NULL) {}
		~Rfc(){}
	};

	//单个对象版本
	//shared_ptr
	template<class _Ty, class Deleter_T = Deleter<_Ty>>
	class shared_ptr
	{
	public:
		shared_ptr(_Ty* p = NULL)
		{
			if (p != NULL)
			{
				_Ptr = new Rfc(p);
			}
		}
		~shared_ptr()
		{
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = NULL;
		}
		shared_ptr(const shared_ptr& src) : _Ptr(src._Ptr)
		{
			if (_Ptr != NULL)
			{
				++_Ptr->_count;
			}
		}
		shared_ptr(shared_ptr&& rval):_Ptr(rval._Ptr)
		{
			rval._Ptr = NULL;
		}

		shared_ptr& operator=(const shared_ptr& src)
		{
			if (this == &src) return *this;
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = src._Ptr;
			if (_Ptr != NULL)
			{
				++_Ptr->_count;
			}
			return *this;
		}
		shared_ptr& operator=(shared_ptr&& rval)
		{
			if (this == &rval) return *this;
			if (_Ptr == rval._Ptr && _Ptr != NULL && rval._Ptr != NULL)
			{
				--_Ptr->_count;
				rval._Ptr = NULL;
				return *this;
			}
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = rval._Ptr;
			rval._Ptr = NULL;
			return *this;
		}
		void reset(_Ty* p = NULL)
		{
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = new Rfc(p);
		}
		operator bool()const
		{
			return _Ptr != NULL;
		}
		_Ty* get()const
		{
			return _Ptr->_mptr;
		}
		_Ty* operator->()
		{
			return get();
		}
		_Ty& operator*()
		{
			return *get();
		}
		size_t use_count()
		{
			return _Ptr->_count;
		}

		void swap(shared_ptr& src)
		{
			std::swap(_Ptr, src._Ptr);
		}
	private:
		Rfc<_Ty>* _Ptr;			//存放引用计数对象地址
		Deleter_T deleter;	//删除器对象
	};

	//多个对象版本
	//shared_ptr
	template<class _Ty, class Deleter_T>
	class shared_ptr<_Ty[], Deleter_T>
	{
	public:
		shared_ptr(_Ty* p = NULL)
		{
			if (p != NULL)
			{
				_Ptr = new Rfc(p);
			}
		}
		~shared_ptr()
		{
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = NULL;
		}
		shared_ptr(const shared_ptr& src) : _Ptr(src._Ptr)
		{
			if (_Ptr != NULL)
			{
				++_Ptr->_count;
			}
		}
		shared_ptr(shared_ptr&& rval) :_Ptr(rval._Ptr)
		{
			rval._Ptr = NULL;
		}

		shared_ptr& operator=(const shared_ptr& src)
		{
			if (this == &src) return *this;
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = src._Ptr;
			if (_Ptr != NULL)
			{
				++_Ptr->_count;
			}
			return *this;
		}
		shared_ptr& operator=(shared_ptr&& rval)
		{
			if (this == &rval) return *this;
			if (_Ptr == rval._Ptr && _Ptr != NULL && rval._Ptr != NULL)
			{
				--_Ptr->_count;
				rval._Ptr = NULL;
				return *this;
			}
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = rval._Ptr;
			rval._Ptr = NULL;
			return *this;
		}
		void reset(_Ty* p = NULL)
		{
			if (_Ptr != NULL && --_Ptr->_count == 0)
			{
				deleter(_Ptr->_mptr);
				delete _Ptr;
			}
			_Ptr = new Rfc(p);
		}
		operator bool()const
		{
			return _Ptr != NULL;
		}
		_Ty* get()const
		{
			return _Ptr->_mptr;
		}
		_Ty* operator->()
		{
			return get();
		}
		_Ty& operator*()
		{
			return *get();
		}
		size_t use_count()
		{
			return _Ptr->_count;
		}

		void swap(shared_ptr& src)
		{
			std::swap(_Ptr, src._Ptr);
		}
		//[]
		_Ty& operator[](size_t index)
		{
			return _Ptr->_mptr[index];
		}
	private:
		Rfc<_Ty>* _Ptr;			//存放引用计数对象地址
		Deleter_T deleter;	//删除器对象
	};
}
#endif

实际上这并不是shared_ptr的最终形态。仿写二中将讲述shared_ptr的真实形态和交叉引用的问题。但是这种实现方式尤为重要！！！