C++ Primer 笔记-- 13 章: 智能指针类

除了使指针成员与指针完全相同之外，另一种方法是定义所谓的智能指针类。智能指针除了增加功能外，其行为像普通指针一样。本例中让智能指针负责删除共享对象。用户将动态分配一个对象并将该对象的地址传给新的 HasPtr类。用户仍然可以通过普通指针访问对象，但绝不能删除指针。HasPtr 类将保证在撤销指向对象的最后一个 HasPtr 对象时删除对象。
新的 HasPtr 类需要一个析构函数来删除指针，但是，析构函数不能无条件地删除指针。如果两个 HasPtr 对象指向同一基础对象，那么，在两个对象都撤销之前，我们并不希望删除基础对象。为了编写析构函数，需要知道这个 HasPtr对象是否为指向给定对象的最后一个。
定义智能指针的通用技术是采用一个使用计数。智能指针类将一个计数器与类指向的对象相关联。使用计数跟踪该类有多少个对象共享同一指针。使用计数为 0 时，删除对象。使用计数有时也称为引用计数。每次创建类的新对象时，初始化指针并将使用计数置为 1。
新的 HasPtr 类保存一个指向 U_Ptr 对象的指针，U_Ptr 对象指向实际的int 基础对象。必须改变每个成员以说明的 HasPtr 类指向一个 U_Ptr 对象而不是一个 int值。

HasPtr 的用户无须担心悬垂指针。只要他们让 HasPtr 类负责释放对象，HasPtr 类将保证只要有指向基础对象的 HasPtr 对象存在，基础对象就存在。

/*
 *private class for use by HasPtr only
 *U_Ptr 类保存指针和使用计数，每个 HasPtr 对象将指向一个 U_Ptr 对象，使用计数将跟踪指向每个
 *U_Ptr 对象的 HasPtr 对象的数目。U_Ptr 定义的仅有函数是构造函数和析构函数，构造函数复制指针，
 *而析构函数删除它。构造函数还将使用计数置为 1，表示一个 HasPtr 对象指向这个 U_Ptr 对象。
 */
class U_Ptr
{
	friend class HasPtr;
	int *ip;
	size_t use;
	U_Ptr(int *p):ip(p), use(1) {}
	~U_Ptr() {delete ip;}
};

/*smart pointer class:takes ownership of dynamically allocated object to which it is bound
 *User code must dynamically allocate an object to initialize a HasPtr
 *and must not delete that object; the HasPtr class will delete it
 */
class HasPtr
{
public:
	//HasPtr has the pointer; p must have been dynamically allocated
	HasPtr(int *p, int i):ptr(new U_Ptr(p)), val(i) {}
	//copy members and increment the use count
	HasPtr(const HasPtr &orig):
		ptr(orig.ptr), val(orig.val) { ++ptr->use;}
	HasPtr& operator=(const HasPtr &);

	//if use count goes to zero, delete the U_Ptr object
	~HasPtr() { if( --ptr->use == 0) delete ptr;}

	//accessors must change to fetch value from U_Ptr object
	int *get_ptr() const { return ptr->ip; }
	int get_int() const { return val; }

	//change the appropriate data member
	void set_ptr(int *p) { ptr->ip = p; }
	void set_int(int i) { val = i; }

	//return or change the value pointed to, so OK for const objects
	//Note: *ptr->ip is equivalent to *(ptr->ip)
	int get_ptr_val() const { return *ptr->ip; }
	void set_ptr_val(int i) { *ptr->ip = i; }

private:
	U_Ptr *ptr; //points to use-counted U_Ptr class
	int val;
};

HasPtr& HasPtr::operator =(const HasPtr &rhs)
{
	++rhs.ptr->use; //increment use count on rhs first
	if( --ptr->use == 0)
	{
		delete ptr;
	}
	ptr = rhs.ptr;
	val = rhs.val;
	return *this;
}