智能指针简单模拟实现

目录

1 基本概念

2 auto_ptr

3 unique_ptr

   4 shared_ptr

 5 weak_ptr

---

1 基本概念

        智能指针是针对资源因捕捉异常跳过资源释放（如下图）、或者开辟了空间没有释放等情况所提出的。其解决的办法就是使用RAII（Resource Acquisition Is Initialization）技术利用对象生命周期来控制程序资源。做法就是把普通的指针封装到类中，在析构函数中进行资源释放。这样就不用显示进行资源释放，只要一个智能指针对象生命周期结束，就会自导调用析构函数释放资源。

void func()
{
    int* pi = new int;
    if(pi == nullptr)    
        throw 1;
    delete pi;
}
int main()
{
    try
    {
        func();
    }
    catch
    {
        cout<

	class smart_ptr
	{
	public:
		smart_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~smart_ptr()
		{
			if (_ptr)
				delete _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

        上述的智能指针中可以自动释放资源了，但是有一个问题是在拷贝构造上。使用拷贝构造会使两个指针指向同一个空间，这样没有问题与原生指针一样。但当析构时同一片空间就会释放两次导致错误。为解决这个问题，又有了以下这些智能指针。

2 auto_ptr

        auto_ptr是C++98的语法，其拷贝构造不是完全的拷贝，而是进行资源转移，将拷贝过来的原指针置空。

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

        这样的做法虽然解决了两次析构，但原指针无法使用与原生指针的情况不同，这并不是我们想看到的。因而auto_ptr没有太大的用途，基本上不使用。后来boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr。C++ 11参考boost中的实现的，引入了unique_ptr和shared_ptr和weak_ptr。unique_ptr对应boost的scoped_ptr。

3 unique_ptr

     unique_ptr也是简单粗暴的将拷贝构造和拷贝赋值直接删除。一个空间只能由一个unique_ptr指向。

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

   4 shared_ptr

        shared_ptr采用引用计数的方式，终于能使用多指针指向一个空间。在引用计数上的增加减少上要使用锁来保证线程安全。

	template
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pRefCount(new int(1))
			,_pmtx(new mutex)
		{}
		shared_ptr(const shared_ptr& sp)
			:_ptr(sp._ptr)
			,_pRefCount(sp._pRefCount)
			,_pmtx(sp._pmtx)
		{
			AddRef();
		}
		shared_ptr& operator=(const shared_ptr& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}
		~shared_ptr()
		{
			Release();
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		void Release()
		{
			_pmtx->lock();
			bool flag = false;
			if (--(*(_pRefCount)) == 0 && _ptr)
			{
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}
			_pmtx->unlock();
			if (flag)
				delete _pmtx;
		}
		void AddRef()
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}
	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};

        shared_ptr已经能解决大部分的场景了，但是在循环引用下就会出问题。例如下图在一个双链表中，A、B、next、prev都使用shared_ptr，A与prev指向一个节点，引用计数为2。B与next也指向一个节点。A、B指针指向节点释放，各自引用计数减1。A中next指向的节点要释放，则B指针指向节点要释放。B指针指向节点要释放，则B中prev指向的节点要先释放，该节点要释放又要释放next指向节点。这样就导致了循环引用问题，两个节点都无法释放。

 5 weak_ptr

        weak_ptr就是为了解决shared_ptr循环引用的。它在拷贝构造和拷贝赋值时的引用计数不增加。注意它不能以原生指针构造，只适用于在循环引用场景将shared_ptr构造为weak_ptr。

	template
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr& sp)
			:_ptr(sp._ptr)
		{}
		weak_ptr& operator=(const shared_ptr& sp)
		{
			_ptr = sp._ptr;
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
	};