代理类，这个类能让我们在一个容器中存储类型不同但相互关联的对象。创建代理将会复制所代理的对象，如果想避免这些复制该怎么办？
通常参数和返回值是通过复制自动传递的，用引用传递参数可以避免这样的复制，但是这样对返回值来说不太容易（比如局部对象）。同样可以用指针来避免复制，但是使用指针有几个问题：
（1）使用对象指针比直接使用对象要困难。
（2）未初始化的指针非常危险，在c++实现中，只要对这样的指针实施复制操作就会出现问题。
（3）无论何时，只要有几个指针指向同一个对象，就必须考虑在什么时候删除这个对象。
为了能够在保持多态性的前提下避免复制对象，c++解决方法就是定义句柄类，将句柄类的对象绑定到它们所控制的类的对象上。
一 怎样绑定（将对象绑定到句柄）？ 这里有两种选择：
（1）可以创建自己的对象并把它赋给一个handle去进行复制。
有对象p， 则 Handle h(p) 将创建p的一个副本，并将handle绑定到该副本。handle 可以控制对该对象副本的操作。
（2）可以把用于创建对象的参数传递给这个handle
有类Point ，创建一个对象方式为：Point p(123,456). 则Handle h(123, 456) 将创建一个句柄，该句柄绑定到point(123,456)。
从效果上说，handle就是一种只包含单个对象的容器。
二 已经将句柄绑定到对象，怎样获取对象？
要是一个handle在行为上类似一个指针，则可以使用operator->将handle的所有操作都转发给相应的Point操作来执行。Point* operator->(); Point * addr = h.operator->() 这样就可以获取对象地址了。如果我们希望handle能够对对象的分配和回收拥有完全的控制权，则最好能够阻止用户直接获得对象的实际地址。所以，如果想把真实的地址隐藏起来，就必须避免使用operator->，而且必须明确的选择让我们的handle类支持哪些Point操作（可以在handle类中照搬Point类中所支持的操作）。
三 句柄类已经设计好了，它到底怎样避免对象复制的？
考虑函数传参的问题，把一个句柄作为参数传给函数，我们希望的是复制句柄而不复制对象。（句柄类和代理类的区别是：句柄类复制的时候只是复制派生类的句柄而不是复制派生类的对象，而代理类复制的时候是复制派生类的对象）为此，我们必须了解有多少个句柄绑定到同一个对象上，只有这样才能确定在何时删除对象，通常使用引用计数来达到这个目的。重新设计一个引用计数类，这个类包含一个引用计数和一个Point对象，称之为UPoint。个人感觉这个UPoint就是更高一层次的抽象，以后handle只要和UPoint打交道就行了，然后由UPoint和Point打交道。UPoint的全部构造方式和Point的一样。这个类纯粹是为了实现而设计的，实际运用中根本没有这个类。因此其所有成员函数都设为私有。以下是几个类的实现代码，有详细注释：
#include <iostream>using namespace std;
class Point{ private:int xval, yval;public:Point() : xval(0), yval(0){ cout << "Point" << endl;}Point(int x, int y) : xval(x), yval(y){ cout << "Point" << endl;}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;}~Point(){ cout << "~Point" << endl;}};
class UPoint //这个类对用户来说是不可见的, 就是一个间接层
{ friend class Handle;Point p; //Point 对象int u; //计数器UPoint():u(1) //提供所有的point的构造方式,这样就可以用任何形式的point对象来实例化UPoint类{ cout << "UPoint::" << u << endl;}UPoint(int x, int y):p(x, y), u(1){ cout << "UPoint::" << u << endl;}UPoint(const Point &p0) : p(p0), u(1){ cout << "UPoint::" << u << endl;}~UPoint(){ cout << "~UPoint::" << u << endl;}};class Handle{ private:UPoint *up; //和间接层UPoint打交道了
public:Handle();Handle(int, int);Handle(const Point&);Handle(const Handle&);Handle& operator=(const Handle&);~Handle();int x() const;Handle& x(int);int y() const;Handle& y(int);};
Handle::Handle():up(new UPoint){ cout << "Handle::" <<up->u << endl; }Handle::Handle(int x, int y):up(new UPoint(x, y)) //按创建Point的方式构造handle，handle->UPoint->Point，handle类只和Upoint类打交道，Upoint类只和Point类打交道{ cout << "Handle::" <<up->u << endl;}Handle::Handle(const Point &p):up(new UPoint(p)) //创建Point的副本
{ cout << "Handle::" <<up->u << endl;}Handle::~Handle(){if(--up->u == 0)//当引用计数的值为0，则删除Upoint的对象（当最后一个句柄对象被析构时，才释放对象）{ cout << "~Handle::" <<up->u << endl; delete up;}else{ cout << "~Handle::" <<up->u << endl;}}Handle::Handle(const Handle &h):up(h.up){ ++up->u; //此处复制的是handle，但是底层的point对象并未复制，只是引用计数加1 （复制的只是句柄，并未复制对象。而代理类复制的却是对象）（复制的只是指向对象的指针，而并未复制对象。正因为不用复制对象，所以相比代理类复制对象的做法开销小。）cout << "Handle::" <<up->u << endl;}Handle& Handle::operator=(const Handle &h){ ++h.up->u; //右边的对象引用计数加1，左边的减1，这样可以确保当左右两个句柄引用同一个Upoint对象时也能正常工作。（可参考沉思录 P61）if(--up->u == 0) delete up;up = h.up;cout << "Handle::" <<up->u << endl;return *this;}
int Handle::x() const{ return up->p.x();}
int Handle::y() const{ return up->p.y();}
void f(Handle h) //测试函数，复制handle，但未复制Point{ cout << h.x() << h.y() << endl;}int main(){ Handle h(3,5);cout << h.x() << h.y() << endl;f(h);return 0;}
另外：
代理类有很多好处,但是麻烦的是每次都得进行复制.如果该类是经常使用并且member很多的话,这样复制的消耗是十分客观的.
因此这里就要介绍另外一种代理类,Handle,也就是句柄类.
为何使用句柄类?
首先就是复制问题.前面有谈到,有些类内部数据很多,采用复制消耗非常大,这种情况下就必须采用句柄类来进行操作.
其次是由于函数的参数和返回值都是采用了复制进行自动传递.虽然c++中引用可以避免,但是很多情况下返回值采用引用并不明智.
对于采用指针的方式,可以解决问题,但是又会引入调用者对于动态管理内存的麻烦.而这往往是很多错误的根源.
何为句柄类呢?
句柄类可以理解为采用了引用计数的代理类.
其多个句柄共享了同一个被代理的类.通过引用计数的方式来减少复制以及内存管理.
其行为类似指针,因此也有智能指针之称,但其实差别很大.后面会有讲述.
句柄类例子:
先有一个简单的类Point
1 class Point 2 { /*{ { { */ 3 public: 4 Point():_x(0),_y(0){} 5 Point(int x,int y):_x(x),_y(y){} 6 int x()const { return _x;} 7 void x(int xv) { _x = xv;} 8 int y()const { return _y;} 9 void y(int yv) { _y = yv;} 10 private: 11 int _x; 12 int _y; 13 };/*}}}*/
接下来我们要定义其的Handle类.
我们的Handle类:
1 class Handle 2 { 3 public: 4 Handle():up(new UPoint){} 5 Handle(int x,int y):up(new UPoint(x,y)){} 6 Handle(const Point&p):up(new UPoint(p)){} 7 Handle(const Handle &h); 8 ~Handle(); 9 Handle& operator=(const Handle &h); 10 int x() const{ return up->p.x(); } 11 int y() const{ return up->p.y(); } 12 Handle& x(int); 13 Handle& y(int); 14 15 16 private: 17 UPoint *up; 18 void allocup(); 19 };
这里说明我们的Handle和指针的不同之处.
也许有读者会对Handle有疑问,为什么不采用operator->来直接操作point呢?
其实顾虑就是operator->返回的是point的地址.也就是使用者可以轻易的获得point的地址进行操作,这并不是我们想要的.这也就是Handle也pointer不想同的地方.
UPoint是为了采用引用计数定义的数据结构
1 //all member is private..only assess by Handle 2 class UPoint 3 { /*{ { { */ 4 friend class Handle; 5 6 Point p; 7 int u;//count 8 9 UPoint():u(0){} 10 UPoint(const Point&pv):p(pv){} 11 UPoint(int x,int y):p(x,y),u(1){} 12 UPoint(const UPoint &up):p(up.p),u(1){} 13 };/*}}}*/
对于Handle类的操作,我们要在Handle类进行复制的时候,累加Handle指向的UPoint的计数值
即复制构造函数以及赋值函数
1 Handle::Handle(const Handle &h) 2 :up(h.up) 3 { 4 ++up->u; 5 } 6 7 Handle& Handle::operator=(const Handle &h) 8 { 9 ++h.up->u; 10 if (--up->u == 0) 11 delete up; 12 up = h.up; 13 return *this; 14 }
而对于析构函数,则是减小引用计数,如果减到0了,就说明没有其他的Handle指向了UPoint,因此我们要删除掉.
1 Handle::~Handle() 2 { 3 if (--up->u == 0) 4 delete up; 5 }
剩下的就是定义Handle对于Point的操作了.即Handle::x(int xv)和Handle::(int yv)了.
这里有2种写法.
一种是像指针一样,对于赋值,就直接修改指向的Point里面的值.这种方法有一个问题,即所以都指向这个Point的Handle类获取的x值都会变化.
代码:
1 //point like 2 Handle& Handle::x(int xv) 3 { 4 up->p.x(xv); 5 return *this; 6 } 7 //point like 8 Handle& Handle::y(int yv) 9 { 10 up->p.y(yv); 11 return *this; 12 }
还有一种是写时复制技术,即每次对于共享的Point进行修改的时候都复制一份新的Point,然后进行修改.
这种技术在Handle中大量采用.在stl中,string也采用了同样的方法.
其额外开销很小,而效率也不差.
代码:
1 void Handle::allocup() 2 { 3 if (up->u != 1) 4 { 5 --up->u; 6 up = new UPoint(up->p); 7 } 8 } 9 10 Handle& Handle::x(int xv) 11 { 12 allocup(); 13 up->p.x(xv); 14 return *this; 15 } 16 17 Handle& Handle::y(int yv) 18 { 19 allocup(); 20 up->p.y(yv); 21 return *this; 22 } 至此,Handle类的第一部分就讲完了.
之后会有第二部分的讲解.解决了多出了一个UPoint的麻烦.
在前文handle part1的部分我讲了一种handle的设计方法。但是那个handle有一个缺点，就是必须要分离出来一个UPoint类做为计数，十分的不方便。这意味着每个类都要单独的出来一个UPoint。而这个UPoint仅仅只是作为计数作用。
在本文中，我们将要设计一种新的写法，利用UseCount类来为Handle所指的对象计数，同时减少UPoint类，同时简化Handle的写法。
在前文中，我们知道了Handle类需要计数。通过计数和指针来完成减少复制，达到优化的目的。
上文的写法：
1 class Point 2 { /*{ { { */ 3 public: 4 Point():_x(0),_y(0){} 5 Point(int x,int y):_x(x),_y(y){} 6 int x()const { return _x;} 7 void x(int xv) { _x = xv;} 8 int y()const { return _y;} 9 void y(int yv) { _y = yv;} 10 private: 11 int _x; 12 int _y; 13 };/*}}}*/ 14 15 16 //all member is private..only assess by Handle 17 class UPoint 18 { /*{ { { */ 19 friend class Handle; 20 21 Point p; 22 int u;//count 23 24 //省略 25 };/*}}}*/ 26 27 class Handle 28 { 29 public: 30 //省略 31 32 private: 33 UPoint *up; 34 }; 可以看到,计数是由UPoint来实现的.由Handle来管理.
但做为编写者的我们肯定是不愿意这么写的.这意味着每写一个Handle都得写一个这样的Uxxxx.实在是费事.
因此,我们可以很直观的想到一个写法,即在Handle里面指向的是Point *p和int *count;
这样就没有这个麻烦了.
当然这是一个很好的解决方案.
这里我再提出一种方案,即抽象引用计数,增加一个UseCount类.
通过这个类来计数.其是通用的.所有的Handle都可以使用.其次,这可以减少我们的指针操作.
实例如下:
被Handle管理的类的声明:
1 class Point 2 { /*{ { { */ 3 public: 4 Point():_x(0),_y(0){} 5 Point(int x,int y):_x(x),_y(y){} 6 int x()const { return _x;} 7 void x(int xv) { _x = xv;} 8 int y()const { return _y;} 9 void y(int yv) { _y = yv;} 10 private: 11 int _x; 12 int _y; 13 };/*}}}*/ 这个和原来的是一样的.
再来看看我们的UseCount
1 class UseCount 2 { 3 public: 4 UseCount():count(new int(1)){} 5 UseCount(const UseCount& uc):count(uc.count){ ++*count;} 6 UseCount& operator=(const UseCount &u); 7 ~UseCount(); 8 bool isonly() { return *count == 1;}//判断是否只指向一个计数,用于判断是否要删除 9 bool reattach(const UseCount &u);//重新连接,用于复制 10 bool makeonly();//分配一个新的,用于写时复制技术 11 private: 12 int *count;//计数 13 }; 14 15 UseCount& UseCount::operator=(const UseCount &u) 16 { 17 reattach(u); 18 return *this; 19 } 20 21 UseCount::~UseCount() 22 { 23 if (--*count == 0) 24 delete count; 25 } 26 bool UseCount::reattach(const UseCount &u) 27 { 28 29 ++*u.count; 30 if (-- *u.count == 0) 31 { 32 delete count; 33 count = u.count; 34 return true; 35 } 36 count = u.count; 37 return false; 38 } 39 40 bool UseCount::makeonly() 41 { 42 if (*count == 1) 43 return false; 44 --*count; 45 count = new int(1); 46 return true; 47 } 这个类实现了计数的功能.其内部有一个count的int 指针.在进行UseCount的复制的时候仅仅是++use.
其他的功能函数我也加了注释.大家应该能看懂.
剩下的就是我们的使用UseCount的Handle类了.
1 class Handle 2 { 3 public: 4 Handle():p(new Point){} 5 Handle(int x,int y):p(new Point(x,y)){}//使用了UseCount使得我们的构造函数显得异常简单, 6 Handle(const Point&pp):p(new Point(pp)){}//仅仅是分配了Point的空间而已 7 Handle(const Handle &h):p(h.p),count(h.count){};//复制构造函数也很简单.其实可以省略,也不会出错 8 ~Handle(); 9 Handle& operator=(const Handle &h); 10 int x() const{ return p->x(); } 11 int y() const{ return p->y(); } 12 Handle& x(int); 13 Handle& y(int); 14 15 16 private: 17 Point *p;//被Handle的对象 18 UseCount count;//使用UseCount 19 }; 我们来看看各个函数
析构函数:
1 Handle::~Handle() 2 { 3 if (count.isonly()) 4 delete p; 5 6 } 这个析构函数判断了p是否只指向了一个对象,如果是的话,因为要析构,所以p也要相应的被删除
=操作符:
1 Handle& Handle::operator=(const Handle &h) 2 { 3 if (count.reattach(h.count)) 4 delete p; 5 p = h.p; 6 return *this; 7 } reattach函数返回bool指,如果count == 1的话,返回值为true,那就要把p给删除.
采用了写时复制技术的x(int),y(int)
1 Handle& Handle::x(int x0) 2 { 3 if (count.makeonly()) 4 p = new Point(*p); 5 p->x(x0); 6 return *this; 7 } 8 9 Handle& Handle::y(int y0) 10 { 11 if (count.makeonly()) 12 p = new Point(*p); 13 p->y(y0); 14 return *this; 15 16 } makeonly()使UseCount分配一个新的计数值,返回true说明需要分配,false则代表其本身就只指向了一个对象,不需要重新分配.
最后是咱们的测试main函数
1 int main() 2 { 3 Handle h(10,10); 4 cout << h.x() << " " << h.y() << endl; 5 h.x(20); 6 cout << h.x() << " " << h.y() << endl; 7 Handle h2(h); 8 cout << h2.x() << " " << h2.y() << endl; 9 return 0; 10 } 总结:
我们可以看到,通过抽象计数对象,我们的Handle的操作显得特别简单,减少了很多的指针操作.同时也减少了出错的可能.
而通过这个方法,我们也减少了一个UPoint类的书写.简化了操作.
Handle类有智能指针一说.其行为有点像指针.同时又省却了我们指针操作的麻烦.而且,减少了很多复制的操作.效率和代码的健壮性得到了提高.
至此,handle(句柄类)的讲解就结束了.