智能指针——实现shared_ptr

前面介绍的auto_ptr和unique_ptr都存在着些许的缺陷，显得不是那么的“智能”，下面我们来看一下较为智能的shared_ptr的设计思路（一块空间、计数器、锁）：

与前两者不同的是shared_ptr用一个count的引用计数将指向同一份内存空间的指针，用_count来表示，这样在析构的时候，会判断_count是否为0，再决定是否示释放空间：

但是并不仅仅是一个_count就能解决的问题，在遇到多线程编程的时候，_count就变成了共享资源，而对_count的操作也就需要多留心一下，为了保证对_count的操作是安全可靠的，所以就引入了mutex

当然shared_ptr也并不是最完美的，还存在着一点的小瑕疵，点击查看解决方案 

 #include <thread>
#include <mutex>
using std::mutex;
using std::cout;
using std::endl;

template <typename T>
class Shared_ptr
{
public:
	Shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		,_pCount(new int(1))
		, _pMutex(new mutex)
	{
		if (ptr == nullptr)
			*_pCount = 0;
	}
	~Shared_ptr()
	{
		Realase();
	}
	Shared_ptr(const Shared_ptr<T>& p)
		:_ptr(p._ptr)
		, _pCount(p._pCount)
		, _pMutex(p._pMutex)
	{
		if (_ptr != nullptr)
			AddCount();
	}
	Shared_ptr& operator=(const Shared_ptr<T>& p)
	{
		if (_ptr != p._ptr)
		{
			Realase();//要释放一下之前所管理的空间，否则会影响到p之前所管理的空间不能正常释放

			_ptr = p._ptr;
			_pCount = p._pCount;
			_pMutex = p._pMutex;

			if (_ptr != nullptr)
				AddCount();
		}
		return *this;
	}

	T& operator*()
	{
		return *this;
	}
	T* operator->()
	{
		return this;
	}

	int AddCount()
	{
		_pMutex->lock();
		++(*_pCount);
		_pMutex->unlock();

		return *_pCount;
	}
	int SubCount()
	{
		_pMutex->lock();
		--(*_pCount);
		_pMutex->unlock();

		return *_pCount;
	}

	int GetCount()
	{
		return *_pCount;
	}

private:
	void Realase()
	{
		if (_ptr && SubCount() == 0)
		{
			delete _ptr;
			delete _pCount;
		}
	}
private:
	T* _ptr;
	int* _pCount;
	std::mutex* _pMutex;
};

以下是我的测试用例：

下图是第一个断点之后的内容：

下图是第二个断点之后的内容

之前提过的shared_ptr会有一个循环引用的缺点，会造成不能正常析构的问题：

#include <memory>
class BB;
class AA
{
public:
	AA() { cout << "AA::AA() called" << endl; }
	~AA() { cout << "AA::~AA() called" << endl; }
	shared_ptr<BB> m_bb_ptr;  //因为BB还未定义，所以在之前先声明一下
};

class BB
{
public:
	BB() { cout << "BB::BB() called" << endl; }
	~BB() { cout << "BB::~BB() called" << endl; }
	shared_ptr<AA> m_aa_ptr; //!
};

int main()
{
	shared_ptr<AA> ptr_a(new AA);
	shared_ptr<BB> ptr_b(new BB);
	cout << "ptr_a use_count: " << ptr_a.use_count() << endl;
	cout << "ptr_b use_count: " << ptr_b.use_count() << endl;

	//下面两句导致了AA与BB的循环引用，结果就是AA和BB对象都不会析构
	ptr_a->m_bb_ptr = ptr_b;
	ptr_b->m_aa_ptr = ptr_a;
	cout << "ptr_a use_count: " << ptr_a.use_count() << endl;
	cout << "ptr_b use_count: " << ptr_b.use_count() << endl;
}

在ptr_a和ptr_b对象中的shared_ptr的没有互相引用之前：ptr_a中有m_bb_ptr，而m_bb_ptr中又有m_aa_ptr就截止了。

在相互连接起来之后：就会无限的循环引用下去，这样两个shared_ptr指针相互保管，谁都不回先释放。所以不能执行析构函数，实际上两个对象ptr_a和ptr_b所指向的资源都只有一个指针指向，而两个对象中的成员都指向了另一个对象。所以造成了歧义，这样不会调用析构函数，造成内存泄漏。

将两个类中的成员类型定义为weak_ptr就可以解决这个问题，因为weak_ptr , 它的构造和析构不会引起引用记数的增加或减少

这是因为weak_ptr是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到shared_ptr不会改变shared_ptr的引用计数【0】。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。即使weak_ptr指向对象，对象也会被释放。

  将AA类和BB类中的成员定义为weak_ptr我们就可以达到正常的逻辑了： 能够正常的析构