C++笔记：面向对象编程（Handle类）

转自：http://blog.csdn.net/liufei_learning/article/details/25020819

句柄类

句柄类的出现是为了解决用户使用指针时需要控制指针的加载和释放的问题。用指针访问对象很容易出现悬垂指针或者内存泄漏的问题。

为了解决这些问题，有许多方法可以使用，句柄类就是其中之一。句柄类是一种包装类，用于存储和管理基类的对象指针，减轻用户使用对象的负担。句柄类使用指针执行操作，虚成员由于既可以指向基类型又可以指向派生类型，所以其行为将在运行时根据句柄实际绑定的对象而变化。

句柄类的设计有两个重要的考虑因素：

• 必须确定复制控制
• 是否屏蔽继承层次（不屏蔽用户需要了解基类对象的使用）

指针型句柄

• 指针型句柄可以像指针一样，将句柄类handler绑定到base类型对象上，并使用*和->执行base类型对象的操作，用户则不必管理handler的指向。指针型句柄将暴露所有的继承层次。
• 句柄类需要三个构造函数：默认构造函数、复制构造函数和使用base类型对象的构造函数。句柄类将保证当句柄对象存在时，base类型对象副本就存在；且使用句柄对象给句柄对象赋值时，将复制指针，而不是对象。除定义三个构造函数外，句柄类还应该定义解引用操作符和箭头操作符，这样可以达到将句柄类绑定到base类型对象上的目的。
• 句柄类同样使用计数来管理副本。句柄类中使用计数指针成员可以使多个句柄类对象可以共享同一计数器。

指针型句柄例子

[cpp] view plain copy print?

1. class Sales_item { //Sales_item 为handle类  
2. public:  
3.     Sales_item():p(0), use(new size_t(1)) {}  
4.     Sales_item(const Item_base& item): p(item.clone()), use(new size_t(1)) {}  
5.     Sales_item(const Sales_item& item):p(item.p), use(item.use) { ++*use; }  
6.     ~Sales_item() { decr_use(); }  
7.   
8.     Sales_item& operator=(const Sales_item&);  
9.     const Item_base* operator->() const;  
10.     const Item_base& operator*() const;  
11.   
12. private:  
13.     void decr_use();  
14. private:  
15.     Item_base *p;  
16.     size_t *use;  
17. };  
18.   
19. Sales_item& Sales_item::operator=(const Sales_item& rhs)  
20. {  
21.     ++*rhs.use;  
22.     decr_use();  
23.     p = rhs.p;  
24.     use = rhs.use;  
25.     return *this;  
26. }  
27.   
28. const Item_base* Sales_item::operator->() const  
29. {  
30.      if(p)  
31.       return p;  
32.      else  
33.       throw logic_error("unbound Sales_item");  
34. }  
35.   
36. const Item_base& Sales_item::operator*() const  
37. {  
38.     if(p)  
39.       return *p;  
40.     else  
41.       throw logic_error("unbound Sales_item");  
42. }  
43.   
44. void Sales_item::decr_use()  
45. {  
46.     if( --*use == 0 )    
47.     {  
48.         delete p;  
49.         delete use;  
50.     }  
51. }  

这个句柄类中要求Item_base类中有一个虚函数clone，这个虚函数的用途是解决基类型对象或者派生类型对象的复制，这样可以不用为句柄类针对每一种派生类型对象建立构造函数。
[cpp] view plain copy print?

1. class Item_base{  
2. public:  
3.     virtual Item_base* clone() const { return new Item_base(*this); }  
4. };  

以上代码即可将Item_base类的指针包装起来。通过对Handler类对象的*和->操作，即可直接访问到所包装的Item_base类型对象。

值型句柄

• 部分时刻用户代码不能直接使用句柄定义的继承层次，用户代码必须通过句柄操作Base类型对象。像一个代理对象（Proximity）一样，句柄类提供众多的对Base类型操作的成员函数及操作符。
• 值型句柄由于常常直接参加运算符与函数操作，而这些运算符和函数中常常会访问到句柄类中的保护部分（protected和private），所以需要在句柄类中将这些运算符与函数都加为友元，使句柄类对自定义的运算符和函数开放。
• 句柄类中同样保持指向基类对象和计数器的两个指针。指针销毁条件和句柄构造函数都与指针型句柄相同。但不同的是，值型句柄不定义*和->两个操作符，基类对象指针完全封闭在句柄类中。
• 推荐值型句柄通过其派生类和基类派生类来完成各种值型操作，保持面向对象的设计风格。

值型句柄例子

[cpp] view plain copy print?

1. class Query {  
2.     friend Query operator~ (const Query&);  
3.     friend Query operator| (const Query&, const Query&);  
4.     friend Query operator& (const Query&, const Query&);  
5.   
6. private:  
7.     Query(Query_base *query): q(query), use(new size_t(1)) {  }  
8. public:  
9.     Query(const string& s): q(new WordQuery(s)), use(new size_t(1)) {  }    
10.     Query(const Query &c): q(c.q), use(c.use) { ++*use; }  
11.     Query& operator= (const Query&);  
12.     ~Query(){ decr_use(); }  
13.   
14.     set<line_no> eval(const TextQuery &t) const  
15.     {   
16.         return q->eval(t);  
17.     }  
18.   
19. private:  
20.     void decr_use();  
21.   
22. private:  
23.     Query_base *q;  
24.     size_t *use;  
25. };  
26.   
27. void Query::decr_use()  
28. {  
29.     if ( --*use == 0 )   
30.     {  
31.         delete q;  
32.         delete use;  
33.     }  
34. }  
35.   
36. Query& Query::operator=(const Query& rhs)  
37. {  
38.     ++*rhs.use;  
39.     decr_use();  
40.     q = rhs.q;  
41.     use = rhs.use;  
42.     return *this;  
43. }  

值型句柄不定义*和->两个操作符，基类对象指针完全封闭在句柄类中。

参考：http://bytes.com/topic/c/insights/651599-handle-classes-smart-pointer
http://my.oschina.net/midnite/blog/156369
http://blog.csdn.net/dhuwxs/article/details/20769877