句柄类

#include
#include
using namespace std;

/*
好事多磨，本来今天不想抄这章代码，看下一章节的，但是，我想了想，小说不可能章章都精彩
*/

///业务处理类
class Point
{
public:
    Point() :xval(0), yval(0){}
    Point(int x, int y) : xval(x), yval(y){}

    int x() const { return xval; }
    int y() const { return yval; }

    Point& x(int xv){ xval = xv; return *this; }
    Point& y(int yv){ yval = yv; return *this; }
    
private:
    int xval, yval;
};

///引用计数器类
class UseCount
{
public:
    UseCount() : p(new int(1)){}

    UseCount(const UseCount& u) :p(u.p)
    {
        ++*p;
    }

    ~UseCount()
    {
        if (--*p == 0)
        {
            delete p;
        }
    }

    bool only()
    {
        return *p == 1;
    }

    bool reattach(const UseCount& u)
    {
        ++*u.p;
        if (--*p == 0)
        {
            delete p;
            p = u.p;
            return true;
        }
        p = u.p;
        return false;
    }

    bool makeonly()
    {
        if (*p == 1)
        {
            return false;
        }
        --*p;
        p = new int(1);
        return true;
    }

private:
    UseCount& operator==(const UseCount&);

private:
    int* p;

};

///句柄类，包含了业务处理类和一个引用计数器
///能够自动管理内存的诀窍:构造函数在创建对象的时候就给成员变量赋了初始值，比如给类Point类创建了内存，给UseCount赋初值
///在调用析构函数的时候去检查了下引用计数器是否等于1，如果等于1就释放掉类Point的内存
///这是C++语言的特性，C无法实现的功能
///这就是C++的奇妙之处，有始有终，在创建对象的时候，给你一个函数进行一些 *** 作，比如变量初始化，申请堆内存，在对象需要销毁的时候
///再给你一个函数进行一些 *** 作，比如销毁堆内存，释放其他资源
class Handle
{
public:
    Handle() : p(new Point){}
    Handle(int x, int y) :p(new Point(x, y)){}
    Handle(const Point& p0) :p(new Point(p0)){}
    Handle(const Handle& h) :u(h.u), p(h.p){}
    ~Handle()
    {
        if (u.only())
        {
            delete p;
        }
    }

    Handle& operator=(const Handle& h)
    {
        if (u.reattach(h.u))
        {
            delete p;
        }
        p = h.p;
        return *this;
    }

    int x() const
    {
        return p->x();
    }

    Handle& x(int x0)
    {
        if (u.makeonly())
        {
            p = new Point(*p);
        }
        p->x(x0);
        return *this;
    }

private:
    Point*        p;
    UseCount    u;

};

int main()
{

    system("pause");
    return 0;
}