Handle的实现

Handle的实现在这里主要是残开淘宝的源代码和c++沉思录

在淘宝的代码里面，定义了一个HandleBase类，他是handle的基类，里面主要的操作是：

1、定义一个Handle准备控制的对象的指针

2、get函数获得这个指针

3、operator*解引用和->操作符

4、bool函数，指针是否为NULL

5、各种关系操作符，在这里定义成非类的成员函数

接着是正式的Handle类的定义：

Handle类管理的对象自身是具有一个引用计算器的，他们都能都有incRef和decRef两个函数

Handle类的成员有：

构造函数、同类型和不同类型的复制构造函数、析构函数、重载赋值操作符

Handle管理的类型里面，每种类型基本上都支持incRef和decRef两个成员函数，这里主要使用引用计算器和需要使用计算器的类型分开，定义成一个Share类专门要你过来操作引用计算器，里面报错incRef、decRef函数、getRef函数等等

c++沉思录里面的example方法基本上是类似的，主要的思想是：分离引用计算器，专门使用一个类UseCount，而Handle里面包含UseCount的一个对象，以及一个Handle管理的对象指针

Handle{

public：

Handle();

Hanlde(const Handle&);

Hanlde(const Point&p);

Hanlde& operator=(const Hanlde&);

~Handle()；

private：

   Point *p;

   UseCount u;

}

#include<iostream>
using namespace std;


class Point{
    public:
        Point():x(0),y(0)
        {
        
        }

        Point(int xx,int yy):x(xx),y(yy)
        {
        
        }

        int getx()const
        {
            return x;
        }

        int gety()const
        {
            return y;
        }

        Point& setx(int xx)
        {
            x = xx;
            return *this;
        }

        Point& sety(int yy)
        {
            y = yy;
            return *this;
        }

    private:
            int x;
            int y;
};


class UPoint{
    private:
        friend class Handle;
        int u;
        Point p;

        UPoint(const Point& pp):u(1),p(pp)
        {
            
        }

        UPoint(int xx,int yy):p(xx,yy),u(1)
        {
        
        }

        UPoint():u(1)
        {
        
        }
};



class Handle{
    public:
        Handle():u(new UPoint)
        {
        
        }

        Handle(int x,int y):u(new UPoint(x,y))
        {
        
        }

        Handle(const Handle& other):u(other.u)
        {
            u->u++;
        }

        Handle(const Point& up)
        {
        
        }

        Handle& operator=(const Handle& other)
        {
            other.u->u--;
            if(--u->u==0){
                delete u;
            }

            u = other.u;

            return *this;
        }

        ~Handle()
        {
            if(--u->u == 0){
                delete u;
            }
        }

        int getx()const
        {
            return u->p.getx();
        }

        int gety()const
        {
            return u->p.gety();
        }
        
        /*

        //value syntax  / use copy on write /
        Handle& setx(int xx)
        {
            if(u->u!=1){
                --u->u;
                u = new UPoint(u->p);
            }

            u->p.setx(xx);

            return *this;
        }

        Handle& sety(int yy)
        {
            if(u->u!=1){
                --u->u;
                u = new UPoint(u->p);
            }

            u->p.sety(yy);

            return *this;
        }

        */

       // /*
         
        //point syntax
        Handle& setx(int xx)
        {
                  u->p.setx(xx);
                  return *this;
        }

        Handle& sety(int yy)
        {
            u->p.sety(yy);
            return *this;
        }

   // */

    private:
            UPoint *u;
};



int main()
{
    Handle h(3,4);
    Handle h1,h2;

    h1 = h;
    h2 = h1;

    h1.setx(100);


    cout<<h1.getx()<<"\t";
    cout<<h2.getx()<<"\t"<<h.getx()<<endl;


    return 0;
}

c++沉思录里面的句柄的第一部分

主要是采用一个中间类同时管理Handle需要管理的对象和被管理对象的引用计算器，这里没有和上面的实力一样将二者分开。

所以当定义一种类型有Handle来管理的时候，都需要重新定义这个中间类（UPoint类）。

并且由于不是指针，所以就算是Point类的继承类也是不行的。