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;
}