#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
/*
使用句柄类的函数也实现了内存的自动管理，同时避免了不需要的内存复制开销
Handle类是框架的概念，Point是业务的概念，UPoint是中间层的概念，因为有UPoint类的存在才能实现内存的自动管理
*/
/*
具体的业务处理类(位图上面的某个点)
*/
class Point
{
public:
?? ?Point() :xval(0), yval(0){}
?? ?Point(int x, int y) : xval(0), yval(0){}
?? ?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;
?? ?int yval;
};
/*
引用计数器不能是句柄的一部分。如果这么干，那么每一个句柄必须知道跟它一起绑定到同一个对象的其他所有句柄的位置，唯有如此
才能更新其他句柄的引用计数器数据。同时，也不能让引用计数器成为对象的一部分，因为那样要求我们重写已经存在的对象类
该类完全是为了实现而实现的
*/
class UPoint
{
?? ?friend class Handle; ?///友元类，为了了句柄类能访问引用计数器和Point类
?? ?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){}
};
/*
之所以使用句柄，原因之一就是为了避免不需要的对象赋值，可以运行多个句柄绑定到单个对象上面
Handle类完全控制了Point类，就必须实现Point的所有功能,?
C++中有构造函数，析构函数，拷贝构造函数，等号操作符和析构函数的概念，
在创建对象的时候利用引用计数器的概念避免了不需要的内存复制
在对象被析构的时候判断引用计数器是否需要销毁对象
这是C++的语言特性，C无法得到的效果
Handle类是框架的概念，Point是业务的概念，UPoint是中间层的概念，
*/
class Handle
{
public:
?? ?Handle() :up(new UPoint){}
?? ?Handle(int x, int y) : up(new UPoint(x, y)){}
?? ?Handle(const Point& p) : up(new UPoint(p)){}
?? ?~Handle()
?? ?{
?? ??? ?if (--up->u == 0)
?? ??? ?{
?? ??? ??? ?delete up;
?? ??? ?}
?? ?}
?? ?Handle(const Handle& h) : up(h.up)
?? ?{
?? ??? ?++up->u;
?? ?}
?? ?Handle& operator=(const Handle& h)
?? ?{
?? ??? ?++h.up->u;
?? ??? ?if (--up->u == 0)
?? ??? ?{
?? ??? ??? ?delete up;
?? ??? ?}
?? ??? ?up = h.up;
?? ??? ?return *this;
?? ?}
?? ?int x() const
?? ?{
?? ??? ?return up->p.x();
?? ?}
?? ?int y() const
?? ?{
?? ??? ?return up->p.y();
?? ?}
?? ?Handle& x(int x0)
?? ?{
?? ??? ?up->p.x(x0);
?? ?}
?? ?Handle& y(int y0)
?? ?{
?? ??? ?up->p.y(y0);
?? ?}
private:
?? ?UPoint* up;
};
int main()
{
?? ?Point p(1, 2);
?? ?Handle h1 = p;
?? ?Handle h2 = p;
?? ?Handle h3 = h1;
?? ?system("pause");
?? ?return 0;
}
