句柄类

为了进行高效对象复制操作而引入句柄类，从内容上来说，句柄是包含单一对象的容器。为了使句柄拥有类似于类指针的作用但是避免类指针的不安全性等缺陷，不允许句柄对->操作符进行定义。为了实现多个句柄捆绑统一对象和安全的销毁操作引入引用计数的概念。进行引用计数相关操作的抽象类称作计数类。
计数类包含以下要点：
构造函数能够立即绑定句柄，从而引用计数在构造成功的时候就是1；
折构函数能够递减引用计数，计数值为0时销毁对象指针。

一个典型的计数类：
 

Code:

1. class UseCount{   
2. int *p;   
3. public:   
4. UseCount:p(new int(1)){}   
5. UseCount(const UseCount&);   
6. UseCount& operator=(const UseCount&);   
7. ~UseCount(){if(--*p==0)delete p;}   
8. bool only(){return *p==1;}   
9. };  

一个典型的句柄：
 

Code:

1. class Handle{   
2. public:   
3. //some code   
4. private:   
5. UseCount u;   
6. Someclass p;   
7. };     

Someclass为该句柄捆绑的类。

-----------------------分割线---------------------

PART II.写时复制
这种通过改变句柄捆绑的对象进行的复制会面临一种问题，例如：
Someclass temp;
handle(t,temp);
handle t2=t;
这时如果处理t2捆绑的对象, t捆绑的对象当然也会变化，但这个不是我们希望的结果，在这种情况下必须进行的复制也就是写时复制，当对象的值改变时必须进行对象的拷贝。
写时复制的思路是，写以前判断该对象是不是捆绑有唯一句柄，如果不是，通过递减引用计数进行复制和分配句柄。

-------------------分割线--------------------------

练习：利用一个基类打印四则运算算式，算式在main中控制。

代码：
 

Code:

1. #include <iostream>   
2.   
3. using namespace std;   
4.   
5. class expr;   
6. class expr_node   
7. {   
8. friend ostream& operator<<(ostream&,const expr&);   
9. friend class expr;   
10. int use;//引用计数   
11. protected:   
12. expr_node():use(1){}//构造函数   
13. virtual void print(ostream&)const=0;   
14. virtual ~expr_node(){}   
15. };   
16. class expr   
17. {   
18. friend ostream& operator<<(ostream&,const expr&);   
19. expr_node* p;   
20. public:   
21. expr(int);   
22. expr(const string&,expr);   
23. expr(const string&,expr,expr);   
24. expr(const expr&);   
25. expr& operator=(const expr&);   
26. ~expr(){if(--p->use==0)delete p;}   
27. };   
28. class int_node:public expr_node   
29. {   
30. friend class expr;   
31. int n;   
32. public:   
33. int_node(int k):n(k){}   
34. void print(ostream& o)const{o<<n;}   
35. };   
36. class unary_node:public expr_node   
37. {   
38. friend class expr;   
39. string temp;   
40. expr opnd;   
41. unary_node(const string& a,expr t):temp(a),opnd(t){}   
42. void print(ostream& o)const{o<<"("<<temp<<opnd<<")";}   
43. };   
44. class binary_node:public expr_node   
45. {   
46. friend class expr;   
47. string temp;   
48. expr opndA,opndB;   
49. binary_node(const string& a,expr t1,expr t2):temp(a),opndA(t1),opndB(t2){}   
50. void print(ostream& o)const{o<<"("<< opndA<<temp<< opndB<<")";}   
51. };   
52. expr::expr(int n){p=new int_node(n);}   
53. expr::expr(const string& a,expr t){p=new unary_node(a,t);}   
54. expr::expr(const string& a,expr  t1,expr  t2){p=new binary_node(a,t1,t2);}   
55. expr::expr(const expr& t){p=t.p; ++p->use;}   
56. expr& expr::operator=(const expr& rhs)   
57. {   
58. rhs.p->use++;   
59. if(--p->use==0)   
60. delete p;   
61. p=rhs.p;   
62. return *this;   
63. };   
64. ostream& operator<<(ostream& o,const expr& t)   
65. {   
66. t.p->print(o);   
67. return o;   
68. };   
69. int main()   
70. {   
71. expr t = expr("*", expr("-", 5), expr("+", 3, 4));   
72. cout<<t<<endl;   
73. t=expr("*",t,t);   
74. cout<<t<<endl;   
75. }