智能指针与句柄类（二）

　　之前文章提到写时复制（copy-on-write）技术，要实现这种功能，针对上文中Handle代码，需要将size_t * use这个抽象出来，封装成一个引用计数类，提供写时复制功能。CUseCount类实现如下：

class CUseCount 
{ 
public: 
    CUseCount(); 
    CUseCount(const CUseCount&); 
    ~CUseCount(); 
 
    bool only()const;   //判断引用计数是否为0, 句柄类无法访问private int*p, 故提供此函数 
    bool reattach(const CUseCount&);    //对计数器的操作, 用来代替 operator = 
 
    bool makeonly();    //写时复制, 表示是否需要赋值对象本身 
 
private: 
    CUseCount& operator=(const CUseCount&); //提供reattach函数代替 operator = 
    int *p; //实现计数 
};

CUseCount::CUseCount():p(new int(1)) 
{} 
 
CUseCount::CUseCount(const CUseCount& u):p(u.p) 
{ 
    ++*p; 
} 
 
CUseCount::~CUseCount() 
{ 
    if(--*p == 0) 
        delete p; 
    p = 0; 
} 
 
bool CUseCount::only()const
{ 
    return *p == 1; 
} 
 
bool CUseCount::reattach(const CUseCount& u) 
{ 
    ++*u.p;     //避免 this == &u, 先对 *u.p 加一 
    if(--*p == 0)   //如果引用计数值为0删除 this->p, 重新绑定p 
    { 
        delete p; 
        p = u.p; 
        return true;//返回true表示句柄此时绑定对象引用数为0, 可删除 
    } 
    p=u.p;      //如果引用计数值不为0，只是重新绑定p 
    return false;   //返回false表示此时仍有句柄绑定到此对象，不可删除 
} 
 
bool CUseCount::makeonly() 
{ 
    if(*p == 1) //确保句柄唯一, 则不需要进行复制 
        return false; 
    //其他情况则必须复制 
    --*p; 
    p = new int(1); 
    return true; 
}

修改之前Handle代码，在其中定义CUseCount对象：

template<class T> class Handle
{
public:
    Handle(T *p = 0);
    Handle(const Handle& h);
    Handle& operator=(const Handle&);
    ~Handle();
    //other member functions
private:
    T* ptr;
    CUseCount u;    //将引用计数类抽象
};

template<class T>   
inline Handle<T>::Handle(T* p):ptr(p) //u 默认构造函数   
{}   

template<class T>   
inline Handle<T>::Handle(const Handle& rhs):u(rhs.u), ptr(rhs.ptr)//u 拷贝构造函数会将引用计数+1   
{}
 
template<class T>
inline Handle<T>& Handle<T>::operator=(const Handle& rhs)   
{
    if(u.reattach())//是否仍有句柄绑定到此对象
        delete ptr;
    ptr = rhs.ptr;
    return *this;
}

template<class T>
inline Handle<T>::~Handle()//同构造函数 u 的析构函数被调用
{
    if(u.only())    //引用计数只有唯一一个对象时，则进行delete操作
        delete ptr;
}

 　　使用引用计数封装后的Handle类运行前一篇中的例子时，仍然会出现*hp随着*hp2重新赋值而改变的情况，此版本的句柄类（即Handle模板类）情况下要实现copy-on-write，目前我能想到的有两种方式：

1 重载句柄类的 operator-> 和 operator* ：

template<class T>
inline T& Handle<T>::operator*()
{
    if(u.makeonly())
        delete ptr;
    ptr = new T(*ptr);

    if(ptr) return *ptr;
    throw std::runtime_error
        ("dereference of unbound Handle");
}

template<class T>
inline T* Handle<T>::operator->()
{
    if(u.makeonly())
        delete ptr;
    ptr = new T(*ptr);

    if(ptr) return ptr;
    throw std::runtime_error
        ("access through of unbound Handle");
}

以这种方式实现的写时复制，基本上所有操作都会调用原生指针的值拷贝（拷贝构造函数），因为除非对象之定义不使用，否则都会调用到operator->和operator*两个函数，而有些操作并没有改变原生指针指向的内容，还是发生了拷贝，很简单的例子：

int main()
{
    Handle<int> hp(new int(12));
    Handle<int> hp2(hp);
    cout<<*hp<<"  "<<*hp2<<endl;

    return 0;
}

代码中对hp2的操作是读操作，但程序依然调用了operator*，进行写时复制，这种情况下是没有必要的，注意到重载的是非const版本的operator->和operator*，而对于const版本的两个函数，默认不进行写时复制，这样就得在编码过程中尽量使用const对象了。

2 写时复制对应具体的操作。不重载operator->和operator*函数，而是具体需要修改T类型成员变量时，进行写时复制，分析下例：

int main()
{
    Handle<string> hp(new string("Grubby"));
    Handle<string> hp2(hp);
    char c = hp[3];
    c = 'e';

    return 0;
}

要在具体（写）操作时实现写时复制，即hp调用operator[]时，那么Handle类必须重载operator[]，在其中完成复制工作：

template<T>
char & Handle<T>::operator[](int index) 
{ 
    if(u.makeonly()) 
        ptr = new T(*ptr); 
    return *ptr[index]; 
}

Handle作为模板类，其中托管的T类型未知，如果针对每个T类型都要试Handle重载一些具体的写操作，那么Handle类会爆炸掉，想到一个方法来避免此种情况，是Handle作为基类，而完成写时复制的类继承自Handle，比如上例中，可以如下修改：

首先修改Handle中的访问标签:

template<class T> class Handle
{
public:
    Handle(T *p = 0);
    Handle(const Handle& h);
    Handle& operator=(const Handle&);
    ~Handle();
    //other member functions
protected:   //使派生类也可以访问此标签下的成员 
    T* ptr;
    CUseCount u;    //将引用计数类抽象
};

 定义继承自Handle<string>的派生类：

class StrHandle : public Handle<string>
{
public:
    char & operator[](int index)    //实现写时复制
    {
        if(u.makeonly())
            ptr = new T(*ptr);
        return *ptr[index];
    }
};

int main()
{
    StrHandle<string> hp(new string("Grubby"));
    StrHandle<string> hp2(hp);
    char c = hp[3];
    c = 'e';

    return 0;
}

　　文中提到的两种实现写时复制方法都比较复杂，不是很直观，添加了很多额外的代码，文中实现的句柄类中引用计数和T类型指针是分开的，而如果将这两个成员封装在一起的话呢？

　　未完待续……