shared_ptr的设计与实现

参考博客：http://blog.youkuaiyun.com/hackbuteer1/article/details/7561235，本文在上述博客基础上使用了模板类来实现shared_ptr并且改进了一个小bug

1.shared_ptr如何自动管理内存？

  我们知道栈上的对象能够在生命周期结束时自动释放，而堆上new出来的对象只能手动delete，shared_ptr即是将普通指针包装起来，只使用shared_ptr的栈对象（如何只允许使用对象的栈对象呢？重载new运算符即可，不是本文重点），而当栈对象生命周期结束时，通过判断条件来决定是否要delete真正被管理的普通指针，这个条件就是“引用计数”，即当前被管理的指针同时被多少个shared_ptr对象管理，当被管理指针的引用计数为0时delete被管理的指针。

  这里给出辅助的引用计数类的实现：

template<typename T>
class PtrRefCountHelper
{
	friend class MySharedPtr<T>;
private:
	T * mp_ptr;	//被管理指针
	size_t use;	//引用计数
	PtrRefCountHelper(T* ptr):mp_ptr(ptr),use(1)
	{

	}
	~PtrRefCountHelper()
	{
		delete mp_ptr;
	}
};

2.如何动态维护引用计数

  哪些操作会导致指向同一内存的堆对象数量发生变化？指针的拷贝、赋值、删除，引用计数的增减逻辑就不赘述了，大家都明白，因此要在拷贝构造、赋值运算符、析构函数中实现相应的逻辑。直接给出代码：

template<typename T>
class PtrRefCountHelper;

template<typename T>
class MySharedPtr
{
public :
	MySharedPtr()
	{

	}
	MySharedPtr(T* ptr):mp_ptr(new PtrRefCountHelper<T>(ptr))
	{

	}
	MySharedPtr(const MySharedPtr& source)
	{
		mp_ptr = source.mp_ptr;
		source.mp_ptr->use++;
	}
	~MySharedPtr()
	{
		if (--mp_ptr->use == 0)
			delete mp_ptr;
	}

	int getRefCount()
	{
		return mp_ptr->use;
	}

	MySharedPtr& operator=(const MySharedPtr& source)
	{
		if (mp_ptr != nullptr)
		{
			if (--mp_ptr->use == 0)
			{
				delete mp_ptr;
			}
		}
		mp_ptr = source.mp_ptr;
		source.mp_ptr->use++;
		return *this;
	}

	T* operator->()
	{
		return mp_ptr->mp_ptr;
	}

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

private:
	PtrRefCountHelper<T>* mp_ptr;
};

3.总结：

  1.引用计数的封装：引用计数是描述被管理的普通指针的描述信息，而不是shared_ptr的描述信息，因此将T* 和 size_t封装到一个对象中。

  2.引用计数类实现的隐藏与数据安全性：通过将PtrRefCountHelper类的所有成员设置为private，保证了外部不可以直接操作引用计数，再通过友元类MySharedPtr实现接口的开放。

4.延申

  引用计数的策略存在一个问题：当两个shared_ptr互相引用时，会出现内存无法释放的情况，因为引用计数始终大于0。解决方法是使用weak_ptr即将下面代码中成员children和parent修改成weak_ptr，weak_ptr是shared_ptr的辅助类，在shared_ptr基础上杜绝了循环引用导致的内存泄露。

class Children;
class Parent {
public:
	~Parent() {
		cout << "Parent    destructor" << endl;
	}

	shared_ptr<Children> children;    //使用weak_ptr
};

class Children {
public:
	~Children() {
		cout << "Children  destructor" << endl;
	}
	shared_ptr<Parent> parent;    //使用weak_ptr
};

void Test()
{
	shared_ptr<Parent> pParent(new Parent());
	shared_ptr<Children> pChildren(new Children());
	if (pParent && pChildren) {
		pParent->children = pChildren;
		pChildren->parent = pParent;
	}

	cout << "pParent use_count: " << pParent.use_count() << endl;
	cout << "pChildren use_count: " << pChildren.use_count() << endl;
}