软件架构设计之Utility模块——智能指针

一：前言

         大家应该明白智能指针的用途（管理动态对象的生命期）及好处。其他话就不多说了，直接看如何实现吧。你将会看到一个基于策略而实作出的无比强大，灵活的智能指针。参考的依然是《Modern C++ Design》一书。

二：原理说明

         软件工程比其他工程有更丰富的多样性。你可以采用多种正确的方法去完成一件事情。一旦你选择了一种解决方案，便会有一大堆变化随之涌现，大至系统架构，小至程序片段。设计的多样性不断困扰着程序员。什么是最好的解决方法？是Events，还是Observers？Callbacks？virtuals？Template？任何设计结构上的问题，都有许多合适的解法，然而他们各有不同规格，并且各有优缺点。因此我们会面临各种不同的抉择。在“一个全功能型接口下实作所有东西”来满足我们各种不同的抉择显然会是失败的。

         Policy有助于我们设计出安全，有效率，高度弹性且高复用性的“设计元素”。所谓Policy：定义一个小型Class或Class Template，他们只是单纯的完成某一方面的主题，在“遵循Policy接口”的前提下，你可以采用任何方法来实作Policy。接着你可以混合和匹配各种Policy，就可以完成一个“行为集”。

         接下来采用此原理来实现我们的“智能指针”。实作完后大家可以认真理解Policy-base design（基于策略的设计）

三：实作

         先来划分智能指针的主题（将其划分为5个）：1.所管理的对象类型（T）2.拥有权策略（OwnerPolicy）3.安全检查策略（CheckPolicy）4.存储策略（StoragePolicy）5.线程策略（ThreadPolicy）。将每个主题作为HTSmartPtr的模板参数。一个主题仅涉及某一特定功能（他们提供统一的接口）。在遵循相应主题的接口下，你可以用不同的方式（Policy实现）完成该主题所需的功能。在每个主题下，你可以选择一种方式（Policy实现）来完成HTSmartPtr。没选择一种不同的Policy实现，你都会产生一种新的智能指针。因此甚至你可以说，可以产生无穷无尽的智能指针。

         现在的问题我的主题一开始划分不正确怎么办。Policy只是很单纯的完成某一功能，因此你完全可以把原因划在A主题的Policy实现，改换成B主题下。这不需要动大量的代码，因为我们已将HTSmartPtr与Policy实现解耦。HTSmartPtr是由Policy实现组合产生的，只不过将这些Policy实现分类。而与HTSmartPt无关。

1.   拥有权策略（OwnerPolicy）

这里我仅提供拥有权策略的三个Policy实现：引用计数，引用计数的观察者，作用域为范围。

由于引用计数及观察者是配套使用的，因此一起讲：

引用计数：等同于boost中的share_ptr。采用该方案的智能指针是可以共享的。

观察者：等同于boost中的weak_ptr。采用该方案的智能指针是不允许外界访问其拥有的对象，必须转换为引用计数（此过程可以判断该对象是否还有效，有效防止类成员变量为指针类型可能出现的野指针问题）。

作用域为范围：用于局部变量，退出作用域时自动释放。不可共享。

看代码：

class HTCounter // 引用智能指针计数器
{
private:
	HTCounter(HTCounter const & );
	HTCounter& operator = (HTCounter const & );

public:
	HTCounter() : m_nRefCount(0), m_nWeakCount(0) {}

	void RefAdd() {++m_nRefCount;}
	bool RefRelease() {--m_nRefCount; return m_nRefCount == 0;}
	HT_UINT GetRefCount() { return m_nRefCount; }

	void WeakAdd() {++m_nWeakCount;}
	bool WeakRelease() {--m_nWeakCount; return m_nWeakCount == 0;}
	HT_UINT GetWeakCount() { return m_nWeakCount; }

	void Swap(HTCounter& rhs)
	{ std::swap(m_nRefCount, rhs.m_nRefCount); std::swap(m_nWeakCount, rhs.m_nWeakCount);}

private:
	HT_UINT m_nRefCount;	// 实际引用计数值
	HT_UINT m_nWeakCount;	// 观察者的引用计数值
};

template <class P>
class WeakCounted;

template <class P>
class RefCounted // 引用计数
{
	template <typename T> friend class WeakCounted;
public:
	RefCounted() : m_pCount(0) {}
	RefCounted(const RefCounted& rhs) : m_pCount(rhs.m_pCount) {}

	template <typename P1>
	RefCounted(const WeakCounted<P1>& rhs) : m_pCount(reinterpret_cast<const WeakCounted<P1>&>(rhs).ValidCounter()) {}

	template <typename P1>
	RefCounted(const RefCounted<P1>& rhs) : m_pCount(reinterpret_cast<const RefCounted&>(rhs).m_pCount)
	{}

	void NewCount()
	{
		m_pCount = static_cast<HTCounter*>(
			HTMemSmall<>::operator new(sizeof(HTCounter)));
		assert(m_pCount);
		new (m_pCount)HTCounter;
		m_pCount->RefAdd();
	}

	P Clone(const P& val)
	{
		if (m_pCount)
			m_pCount->RefAdd();
		return m_pCount ? val : HT_NULL;
	}

	bool Release(const P&)
	{
		if (m_pCount && m_pCount->RefRelease())
		{
			// 当引用计数、观察者计数均为0时释放计数器
			if (!m_pCount->GetWeakCount())
			{
				m_pCount->~HTCounter();
				HTMemSmall<>::operator delete(m_pCount, sizeof(HTCounter));
				m_pCount = 0;
			}
			return true;
		}

		return false;
	}

	void Swap(RefCounted& rhs)
	{
		std::swap(m_pCount, rhs.m_pCount);
	}

private:
	HTCounter*  m_pCount;
};

template <class P>
class WeakCounted // 观察者计数
{
public:
	WeakCounted() : m_pCount(0) {}
	WeakCounted(const WeakCounted& rhs) : m_pCount(rhs.m_pCount) {}

	template <typename P1>
	WeakCounted(const RefCounted<P1>& rhs) : m_pCount(reinterpret_cast<const RefCounted<P1>&>(rhs).m_pCount) {}
	template <typename P1>
	WeakCounted(const WeakCounted<P1>& rhs) : m_pCount(reinterpret_cast<const WeakCounted&>(rhs).m_pCount) {}

	void NewCount() { assert(false); }

	P Clone(const P& val)
	{
		if (m_pCount)
			m_pCount->WeakAdd();
		return val;
	}

	bool Release(const P&)
	{
		if (m_pCount && m_pCount->WeakRelease())
		{
			// 当引用计数、观察者计数均为0时释放计数器
			if (!m_pCount->GetShareCount())
			{
				HTMemSmall<>::operator delete(m_pCount, sizeof(HTCounter));
				m_pCount = 0;
			}
		}

		return false;
	}

	HTCounter* ValidCounter() const
	{
		// 当引用计数非0
		if (m_pCount && m_pCount->GetShareCount())
			return m_pCount;

		return HT_NULL;
	}

	void Swap(WeakCounted& rhs)
	{ std::swap(m_pCount, rhs.m_pCount); }

	template <typename T> friend class RefCounted;
private:
	HTCounter* m_pCount;
};

template <class P>
class OwnerScoped
{
public:
	void NewCount() {}
	bool Release(const P&) { return true; }
};

2.   安全检查策略（CheckPolicy）

这里仅提供两种Plicy实现：CheckNo（不进行任何检查），CheckAssert（提领前进行assert检查是否为null）。

CheckNo： 不提供任何检验

CheckAssert：// 提领前断言检验

template <class P>
struct CheckNo
{
	CheckNo() {}
	template <class P1>
	CheckNo(const CheckNo<P1>&) {}
	static void OnDefault(const P&) {}
	static void OnInit(const P&) {}
	static void OnDereference(const P&) {}
	static void Swap(CheckNo&) {}
};

template <class P>
struct CheckAssert
{
	CheckAssert() {}

	template <class P1>
	CheckAssert(const CheckAssert<P1>&) {}
	template <class P1>
	CheckAssert(const CheckNo<P1>&) {}

	static void OnDefault(const P&) {}
	static void OnInit(const P&) {}
	static void OnDereference(P val)
	{
		assert(val);
		(void) val;
	}

	static void Swap(CheckAssert&) {}
};

3.   存储策略（StoragePolicy）：

这里仅提供三种Policy实现：StorageNo（不为所管理的对象分配内存），StoragePool（在内存池中分配对象），StorageNew（即使用new 分配对象，delete释放对象）。

StorageNo：不含分配对象内存功能

StoragePool：在内存池中为对象分配空间，这里选用的是HTMemFlex，可参看内存分配部分

StorageNew：使用new分配，delete释放

template <typename T>
class HTStorageNo
{
public:
	typedef T			value_type;
	typedef T*			pointer;
	typedef const T*	const_pointer;
	typedef T&			reference;
	typedef const T&	const_reference;
	typedef T*			stored_type;

	HTStorageNo() : m_pT(0) {}
	HTStorageNo(const HTStorageNo&) {}
	template <class U>
	HTStorageNo(const HTStorageNo<U>&);// {}
// 	template <class U>
// 	HTStorageNo(const YKStorageChunk<U>&) {}

	void Create() { assert(false); }
	void  Destroy() { assert(false); }

	pointer operator-> () const { BOOST_STATIC_ASSERT(0); return m_pT;}
	reference operator* () const { BOOST_STATIC_ASSERT(0); return *m_pT;}
	void Swap(HTStorageNo& rhs)
	{ std::swap(m_pT, rhs.m_pT); }

	friend inline pointer GetImpl(const HTStorageNo& sp)
	{ return sp.m_pT; }
	friend inline const stored_type& GetImplRef(const HTStorageNo& sp)
	{ return sp.m_pT; }
	friend inline stored_type& GetImplRef(HTStorageNo& sp)
	{ return sp.m_pT; }

private:
	stored_type		m_pT;
};

template <typename T>
class HTStorageNew
{
public:
	typedef T			value_type;
	typedef T*			pointer;
	typedef const T*	const_pointer;
	typedef T&			reference;
	typedef const T&	const_reference;
	typedef T*			stored_type;

	void Create() { m_pT = new T(); }
	void  Destroy() { delete m_pT; m_pT = 0; }

	pointer operator-> () const {return m_pT;}
	reference operator* () const {return *m_pT;}
	void Swap(HTStorageNew& rhs)
	{std::swap(m_pT, rhs.m_pT);}

	friend inline pointer GetImpl(const HTStorageNew& sp)
	{return sp.m_pT;}
	friend inline const stored_type& GetImplRef(const HTStorageNew& sp)
	{return sp.m_pT;}
	friend inline stored_type& GetImplRef(HTStorageNew& sp)
	{return sp.m_pT;}

private:
	stored_type		m_pT;
};

template <typename T>
class HTStoragePool : public HTMemFlex<T>
{
public:
	typedef T			value_type;
	typedef T*			pointer;
	typedef const T*	const_pointer;
	typedef T&			reference;
	typedef const T&	const_reference;
	typedef T*			stored_type;

public:
	HTStoragePool() : m_pT(0) {}
	HTStoragePool(const HTStoragePool&) {}
	template <class U>
	HTStoragePool(const HTStoragePool<U>&) {}
// 	template <class U>
// 	HTStoragePool(const YKStorageNo<U>&) {}

	HTStoragePool(const stored_type& p) : m_pT(p) {}
	~HTStoragePool() {}

	void Create() { m_pT = Allocate(sizeof(value_type)); }
	void  Destroy() { Deallocate(m_pT); m_pT = 0; }

	pointer operator-> () const {return m_pT;}
	reference operator* () const {return *m_pT;}
	void Swap(HTStoragePool& rhs)
	{std::swap(m_pT, rhs.m_pT);}

	friend inline pointer GetImpl(const HTStoragePool& sp)
	{return sp.m_pT;}
	friend inline const stored_type& GetImplRef(const HTStoragePool& sp)
	{return sp.m_pT;}
	friend inline stored_type& GetImplRef(HTStoragePool& sp)
	{return sp.m_pT;}

private:
	stored_type		m_pT;
};

4.   线程策略（ThreadPolicy）

         两个Policy实现：ThreadSingle（单线程实现），ThreadMulti（多线程实现）

         ThreadSingle：不用加锁保护，用于单线程环境。

         ThreadMulti：可用于多线程环境。

暂不实现该策略，等实现完线程部分再来实在该策略。

5.   将一切组装起来

默认实现一个引用计数，不进行任何检查，使用自定义内存池来分配对象的智能指针。

template <typename T, 
	template <class> class OwnerPolicy = RefCounted,
	template <class> class CheckPolicy = CheckNo,
	template <class> class StoragePolicy = HTStoragePool>
class HTSmartPtr : public StoragePolicy<T>
	, public OwnerPolicy<typename StoragePolicy<T>::pointer>
	, public CheckPolicy<typename StoragePolicy<T>::stored_type>
{
	typedef StoragePolicy<T>		MP;
	typedef OwnerPolicy<typename StoragePolicy<T>::pointer> OP;
	typedef CheckPolicy<typename StoragePolicy<T>::stored_type> KP;
public:
	typedef typename MP::reference			reference;
	typedef typename MP::const_reference	const_reference;
	typedef typename MP::pointer			pointer;
	typedef typename MP::const_pointer		const_pointer;
	typedef typename MP::value_type			value_type;

public:
	HTSmartPtr(bool bNew = false)	// 需要分配对象则传true
	{
		if (bNew)
		{
			NewObj();
		}
	}

	void NewObj()
	{
		assert(!ValidObj());
		Create();
		NewCount();
	}

	HTSmartPtr(int rhs)	// 只接受HT_NULL,不接受裸指针
	{
		assert(rhs == HT_NULL);
		HTSmartPtr temp;
		temp.Swap(*this);
	}

	HTSmartPtr(HTSmartPtr& rhs)
		: MP(rhs), OP(rhs), KP(rhs)
	{
		GetImplRef(*this) = OP::Clone(GetImplRef(rhs));
	}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	HTSmartPtr(const HTSmartPtr<T1, OP1, KP1, MP1>& rhs)
		: MP(rhs), OP(rhs), KP(rhs)
	{
		GetImplRef(*this) = OP::Clone(HT_Safe_DownCast<pointer>(GetImplRef(rhs)));
	}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	HTSmartPtr(HTSmartPtr<T1, OP1, KP1, MP1>& rhs)
		: MP(rhs), OP(rhs), KP(rhs)
	{
		GetImplRef(*this) = OP::Clone(HT_Safe_DownCast<pointer>(GetImplRef(rhs)));
	}

	HTSmartPtr& operator= (HTSmartPtr& rhs)
	{
		HTSmartPtr temp(rhs);
		temp.Swap(*this);
		return *this;
	}

	HTSmartPtr& operator= (int rhs)
	{
		assert(rhs == HT_NULL);
		HTSmartPtr temp;
		temp.Swap(*this);
		return *this;
	}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	HTSmartPtr& operator= (const HTSmartPtr<T1, OP1, KP1, MP1>& rhs)
	{
		HTSmartPtr temp(rhs);
		temp.Swap(*this);
		return *this;
	}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	HTSmartPtr& operator= (HTSmartPtr<T1, OP1, KP1, MP1>& rhs)
	{
		HTSmartPtr temp(rhs);
		temp.Swap(*this);
		return *this;
	}

	void Swap(HTSmartPtr& rhs)
	{
		OP::Swap(rhs);
		KP::Swap(rhs);
		MP::Swap(rhs);
	}

	~HTSmartPtr() 
	{
		if (OP::Release(GetImpl(*static_cast<MP*>(this))))
		{
			Destroy();
		}
	}

	pointer operator-> ()
	{
		KP::OnDereference(GetImplRef(*this));
		return MP::operator ->();
	}

	pointer operator-> () const
	{
		KP::OnDereference(GetImplRef(*this));
		return MP::operator ->();
	}

	reference operator* ()
	{
		KP::OnDereference(GetImplRef(*this));
		return MP::operator *();
	}

	reference operator* () const
	{
		KP::OnDereference(GetImplRef(*this));
		return MP::operator *();
	}

	inline friend HT_BOOL operator==(const HTSmartPtr& lhs, const_pointer rhs)
	{ return GetImpl(lhs) == rhs; }

	inline friend HT_BOOL operator==(const_pointer lhs, const HTSmartPtr& rhs)
	{ return rhs == lhs; }

	inline friend HT_BOOL operator!=(const HTSmartPtr& lhs, const_pointer rhs)
	{ return !(lhs == rhs); }

	inline friend HT_BOOL operator!=(const_pointer lhs, const HTSmartPtr& rhs)
	{ return rhs != lhs; }

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	inline HT_BOOL operator== (const HTSmartPtr<T1, OP1, KP1, MP1>& rhs) const
	{return *this == GetImpl(rhs);}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	inline bool operator!= (const HTSmartPtr<T1, OP1, KP1, MP1>& rhs) const
	{return !(*this == rhs);}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	inline bool operator< (const HTSmartPtr<T1, OP1, KP1, MP1>& rhs) const
	{return !(*this < rhs);}

	template <typename T1, 
		template <class> class OP1,
		template <class> class KP1,
		template <class> class MP1>
	inline bool operator> (const HTSmartPtr<T1, OP1, KP1, MP1>& rhs) const
	{return !(*this > rhs);}

	inline pointer GetValue()
	{ return GetImpl(*this); }
	inline pointer GetValue() const
	{ return GetImpl(*this); }

	inline bool ValidObj()
	{ return GetImpl(*this) != 0; }
	inline bool ValidObj() const
	{ return GetImpl(*this) != 0; }