智能指针与句柄类（一）

　　句柄类/智能指针（smart point）是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。句柄类实际上是通过复制指向引用计数器类型的指针，来代替复制实际对象；从而使得复制对象变成复制指针，实现虚拟复制（即是用复制对象的地址代替复制对象本身），以提高内存效率和访问速度。

　　引用计数是复制控制成员中使用的技术，跟踪该类有多少个对象共享一个指针。引用计数与共享对象一起存储，需要创建一个单独类指向共享对象并管理引用计数。由构造函数而不是赋值构造函数设置共享对象的状态并将引用计数置为1，每次有复制构造函数或赋值操作符生成新的副本时，引用计数加1，由析构函数撤销对象或作为赋值操作符的左操作数撤销对象时，引用计数减1，赋值操作符和析构函数对引用计数进行判断是否为0，如果是，则撤销对象。

　　通用的句柄类模板实现如下（摘自《C++ Primer》）：

template<class T> class Handle
{
public:
    Handle(T *p = 0):ptr(p), use(new size_t(1)){}
    T& operator*();
    T* operator->();

    const T& operator*()const;
    const T* operator->()const;

    Handle(const Handle& h):ptr(h.ptr), use(h.use)
    { ++*use; }

    Handle& operator=(const Handle&);
    ~Handle() { rem_ref(); }

private:
    T* ptr;            //shared object
    size_t *use;    //count of how many Handles spoint to *ptr
    void rem_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
    rem_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 of 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 of unbound Handle");
}

使用句柄类的例子：

int main()
{
    Handle<int> hp(new int(42));
    {
        //new scope
        Handle<int> hp2 = hp;
        cout<<*hp<<"  "<<*hp2<<endl;
        *hp2 = 10;
    }
    cout<<*hp<<endl;
    return 0;
}

代码line6使用hp构造了新的Handle对象hp2，二者指向同一块内存。line8对*hp2重新赋值，此时二者指向内存值由42变为10，退出new scope后，hp2对象析构，但引用计数值未减小到0，line10输出*hp的值，由于二者指向内存空间相同，所以此处输出10，之前的42被覆盖，退出main函数时，引用计数减小到0，此时hp析构函数将构造时分配的空间delete。

　　可以看出，上面展示的句柄类可以完成动态分配指针的托管，并且高效完成复制与赋值操作。但是在改变*hp2时，hp托管的对象值同样改变了，这可能会违背开发人员的意愿，毕竟hp和hp2是两个对象。在更改hp2时，要做到防止hp托管对象被改变，那么句柄类需要自动复制对象并与原对象断开，这被称为写时复制（copy-on-write）。

　　未完待续……