句柄（二）

——将句柄与使用者信息分离，以类的形式存在

　　1.　　计数类：控制计数的类，被嵌入句柄来使用，实现功能分离

　　2.　　实现代码

　　　　　

#include <iostream>
using namespace std;

// 计数部分
class UseCount
{
private:
    int *p;
    UseCount& operator=(const UseCount&);
public:
    UseCount():p(new int(1)){}
    UseCount(const UseCount& u):p(u.p){*p++;}
    ~UseCount(){if (--*p==0) delete p;};

    bool only();
    bool reattach(const UseCount&);
    bool makeonly();
};

UseCount& UseCount::operator=(const UseCount& u)
{
    reattach(u);
    return *this;
}

bool UseCount::only()
{
    // 检测句柄是否唯一
    return *p==1;
}

bool UseCount::reattach(const UseCount& u)
{
    // 替换句柄指向的对象，当被替换的是唯一的句柄时返回true
    ++*u.p;
    if (--*p==0)
    {
        delete p;
        p = u.p;
        return true;
    }
    p = u.p;
    return false;
}

bool UseCount::makeonly()
{
    // 使该句柄被分离，被替分离的如果是唯一的句柄，那么分离失败
    if (*p==1)
        return false;
    --*p;
    p = new int(1);
    return true;
}

// 句柄指向的类
class digit
{
private:
    int x;
public:
    digit(){}
    digit(int x_):x(x_){}
    int xx() {return x;}
    void xx(int x_){x = x_;}
};

// 句柄
class handle
{
private:
    digit *u;
    UseCount p;
public:
    handle():u(0){}
    handle(int x):u(new digit(x)){}
    handle(const digit &dg):u(new digit(dg)){}
    handle(const handle &han):u(han.u),p(han.p){}
    handle& operator=(const handle& han);
    // 存取函数
    int x() {return u->xx();}
    handle& x(int x_);
    ~handle(){if (p.only()) delete(u);}
};

handle& handle::operator=(const handle& han)
{
    if (p.reattach(han.p))
        delete(u);
    u = han.u;
    return *this;
}

handle& handle::x(int x_)
{
    if (p.makeonly())
        u = new digit(*u);
    u->xx(x_);
    return *this;
}

int main()
{
    handle han1(3);
    handle han2 = han1;
    handle han3 = han2;
    printf("han3: %d
", han3.x());
    han3.x(5);
    printf("han2: %d
", han2.x());
    printf("han3: %d
", han3.x());
    return 0;
}

输出结果为：han3:　　3

　　　　　　han2:　　3

　　　　　　han3:　　5