语言基础（24）：句柄类

1、句柄类可以做到两点好处：

▪ 减少编译量，修改底层类，不需要编译句柄类；
▪ 隔离信息，隐藏了底层细节，用户只能够看到，类开放出来的接口；

2、实现一个泛型句柄类：

template <class T> class Handle {
public:
	// unbound handle
	Handle(T *p = 0): ptr(p), use(new size_t(1)) { }
	// overloaded operators to support pointer behavior
	T& operator*();
	T* operator->();
	const T& operator*() const;
	const T* operator->() const;
	// copy control: normal pointer behavior, but last Handle deletes the object
	Handle(const Handle& h): ptr(h.ptr), use(h.use) { ++*use; }
	Handle& operator=(const Handle&);
	~Handle() { rm_ref(); }
	
private:
	T* ptr;      // shared object
	size_t *use; // count of how many Handle point to *ptr
	
	void rm_ref() { if (--*use == 0) { delete ptr; delete use; } }
};

template <class T>
inline Handle<T>& Handle<T>::operator=(const Handle &rhs)
{
	++*rhs.use; // protect against self-assignment
	rm_ref();   // decrement use count and delete pointers if needed
	ptr = rhs.ptr;
	use = rhs.use;
	return *this;
}

template <class T> inline T& Handle<T>::operator*()
{
	if (ptr) return *ptr;
	throw std::runtime_error
		("dereference of unbound Handle");
}

template <class T> inline T* Handle<T>::operator->()
{
	if (ptr) return ptr;
	throw std::runtime_error
		("access through unbound Handle");
}

template <class T> inline const T& Handle<T>::operator*() const
{
	if (ptr) return *ptr;
	throw std::runtime_error
		("dereference of unbound Handle");
}

template <class T> inline const T* Handle<T>::operator->() const
{
	if (ptr) return ptr;
	throw std::runtime_error
		("access through unbound Handle");
}