c++沉思录-Handle

写在这里，方便以后上网闲逛的时候，来看看，没有编译，只理解思想

class Point
{
private:
int xval,yval;
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;}
};

//第一种方式，不可取，每个派生类都需要写一个对应类
class UPoint
{
public:
friend class Handle;
Point p;
int u;
UPoint():u(1){}
UPoint(int x,int y):p(x,y),u(1){}
UPoint(const Point& p0):p(p0),u(1){}
};


class Handle
{
private:
UPoint* up;
public:
Handle():up(new UPoint()){}
Handle(int x,int y):up(new UPoint(x,y)){}
Handle(const Point& p0):up(new UPoint(p0)){}
Handle(const Handle& o):up(o.up){++up->u;}
Handle& operator=(const Handle& o)
{
if (--up->u == 0)
delete up;
++o.u;
up = o.up;
return *this;
}
~Handle(){if (--up->u) delete up;}
int x() const {return up->p.x();}
Handle& x(int xv)
{
//指针语义
//up->p.x=xv;
//return *this;

//值语义
up = MyObject();
up->p.x(xv);
return *this;
}
int y() const {return up->p.y();}
Handle& y(int yv)
{
//指针语义
//up->p.y=yv;
//return *this;
//值语义
up = MyObject();
up->p.y(yv);
return *this;
}
UPoint* MyObject()
{
if (up->u != 1)
{
//多个
--up.u;
//重新构造一个up为自己所用
up = new UPoint(up->p);
}
return up;
}
};

//第二种方式，分离计数和对象，但是计数太简单，逻辑都写在了CHanlde里

class CHandle
{
private:
Point* p;
int* u;
public:
CHandle():p(new Point),u(new int(1)){}
CHandle(int xv,int yv):p(new Point(xv,yv)),u(new int(1)){}
CHandle(const Point& p0):p(new Point(p0),u(new int(1)){}
CHandle(const CHandle& h):p(h.p),u(h.u){++*u;}
CHandle& operator=(const CHandle& o)
{
if (--*u == 0)
{
delete p;
delete u;
}
p = o.p;
u = o.u;
++*u;
return *this;
}
~CHandle()
{
if (--*u == 0)
{
delete p;
delete u;
}
}
};

//第三种方式，计数使用一个对象来进行专门的管理，Handle根据这个计数接口来管理实际对象
class UseCount
{
private:
int *p;
public:
UseCount():p(new int(1)){}
UseCount(const UseCount& o):p(o.p){++*p;}
UseCount& operator=(const UseCount& o)
{
if (--*p == 0)
delete p;
p = o.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;
}
};
class UHandle
{
private:
Point *p;
UseCount u;
public:
UHandle():p(new Point()){}
~UHanlde()
{
if (u.only())
delete p;
}
UHandle(const Point& p0):p(new Point(p0)){}
UHandle(const UHandle& o):p(o.p),u(o.u){}
UHandle& operator=(const UHandle& o)
{
/*
if (u.only())
delete p;
u = o.u;
p = o.p;

return *this;
*/
if (u.reattach(o.u))
delete p;
p = o.p;
return *this;
}
int x() const{return p->x();}
Handle& x(int xv)
{
if (u.makeonly())
p = new Point(*p);
p->x(xv);
return *this;
}
};