智能指针与句柄类（二） - Tourun

公告

　　之前文章提到写时复制（copy-on-write）技术，要实现这种功能，针对上文中Handle代码，需要将size_t * use这个抽象出来，封装成一个引用计数类，提供写时复制功能。CUseCount类实现如下：

 1 class CUseCount 
 2 { 
 3 public: 
 4     CUseCount(); 
 5     CUseCount(const CUseCount&); 
 6     ~CUseCount(); 
 7  
 8     bool only()const;   //判断引用计数是否为0, 句柄类无法访问private int*p, 故提供此函数 
 9     bool reattach(const CUseCount&);    //对计数器的操作, 用来代替 operator = 
10  
11     bool makeonly();    //写时复制, 表示是否需要赋值对象本身 
12  
13 private: 
14     CUseCount& operator=(const CUseCount&); //提供reattach函数代替 operator = 
15     int *p; //实现计数 
16 };
17 
18 CUseCount::CUseCount():p(new int(1)) 
19 {} 
20  
21 CUseCount::CUseCount(const CUseCount& u):p(u.p) 
22 { 
23     ++*p; 
24 } 
25  
26 CUseCount::~CUseCount() 
27 { 
28     if(--*p == 0) 
29         delete p; 
30     p = 0; 
31 } 
32  
33 bool CUseCount::only()const
34 { 
35     return *p == 1; 
36 } 
37  
38 bool CUseCount::reattach(const CUseCount& u) 
39 { 
40     ++*u.p;     //避免 this == &u, 先对 *u.p 加一 
41     if(--*p == 0)   //如果引用计数值为0删除 this->p, 重新绑定p 
42     { 
43         delete p; 
44         p = u.p; 
45         return true;//返回true表示句柄此时绑定对象引用数为0, 可删除 
46     } 
47     p=u.p;      //如果引用计数值不为0，只是重新绑定p 
48     return false;   //返回false表示此时仍有句柄绑定到此对象，不可删除 
49 } 
50  
51 bool CUseCount::makeonly() 
52 { 
53     if(*p == 1) //确保句柄唯一, 则不需要进行复制 
54         return false; 
55     //其他情况则必须复制 
56     --*p; 
57     p = new int(1); 
58     return true; 
59 }

View Code

修改之前Handle代码，在其中定义CUseCount对象：

 1 template<class T> class Handle
 2 {
 3 public:
 4     Handle(T *p = 0);
 5     Handle(const Handle& h);
 6     Handle& operator=(const Handle&);
 7     ~Handle();
 8     //other member functions
 9 private:
10     T* ptr;
11     CUseCount u;    //将引用计数类抽象
12 };
13 
14 template<class T>   
15 inline Handle<T>::Handle(T* p):ptr(p) //u 默认构造函数   
16 {}   
17 
18 template<class T>   
19 inline Handle<T>::Handle(const Handle& rhs):u(rhs.u), ptr(rhs.ptr)//u 拷贝构造函数会将引用计数+1   
20 {}
21  
22 template<class T>
23 inline Handle<T>& Handle<T>::operator=(const Handle& rhs)   
24 {
25     if(u.reattach())//是否仍有句柄绑定到此对象
26         delete ptr;
27     ptr = rhs.ptr;
28     return *this;
29 }
30 
31 template<class T>
32 inline Handle<T>::~Handle()//同构造函数 u 的析构函数被调用
33 {
34     if(u.only())    //引用计数只有唯一一个对象时，则进行delete操作
35         delete ptr;
36 }

View Code

　　使用引用计数封装后的Handle类运行前一篇中的例子时，仍然会出现*hp随着*hp2重新赋值而改变的情况，此版本的句柄类（即Handle模板类）情况下要实现copy-on-write，目前我能想到的有两种方式：

1 重载句柄类的 operator-> 和 operator* ：

 1 template<class T>
 2 inline T& Handle<T>::operator*()
 3 {
 4     if(u.makeonly())
 5         delete ptr;
 6     ptr = new T(*ptr);
 7 
 8     if(ptr) return *ptr;
 9     throw std::runtime_error
10         ("dereference of unbound Handle");
11 }
12 
13 template<class T>
14 inline T* Handle<T>::operator->()
15 {
16     if(u.makeonly())
17         delete ptr;
18     ptr = new T(*ptr);
19 
20     if(ptr) return ptr;
21     throw std::runtime_error
22         ("access through of unbound Handle");
23 }

View Code

以这种方式实现的写时复制，基本上所有操作都会调用原生指针的值拷贝（拷贝构造函数），因为除非对象之定义不使用，否则都会调用到operator->和operator*两个函数，而有些操作并没有改变原生指针指向的内容，还是发生了拷贝，很简单的例子：

1 int main()
2 {
3     Handle<int> hp(new int(12));
4     Handle<int> hp2(hp);
5     cout<<*hp<<"  "<<*hp2<<endl;
6 
7     return 0;
8 }

View Code

代码中对hp2的操作是读操作，但程序依然调用了operator*，进行写时复制，这种情况下是没有必要的，注意到重载的是非const版本的operator->和operator*，而对于const版本的两个函数，默认不进行写时复制，这样就得在编码过程中尽量使用const对象了。

2 写时复制对应具体的操作。不重载operator->和operator*函数，而是具体需要修改T类型成员变量时，进行写时复制，分析下例：

1 int main()
2 {
3     Handle<string> hp(new string("Grubby"));
4     Handle<string> hp2(hp);
5     char c = hp[3];
6     c = 'e';
7 
8     return 0;
9 }

View Code

要在具体（写）操作时实现写时复制，即hp调用operator[]时，那么Handle类必须重载operator[]，在其中完成复制工作：

1 template<T>
2 char & Handle<T>::operator[](int index) 
3 { 
4     if(u.makeonly()) 
5         ptr = new T(*ptr); 
6     return *ptr[index]; 
7 }

View Code

Handle作为模板类，其中托管的T类型未知，如果针对每个T类型都要试Handle重载一些具体的写操作，那么Handle类会爆炸掉，想到一个方法来避免此种情况，是Handle作为基类，而完成写时复制的类继承自Handle，比如上例中，可以如下修改：

首先修改Handle中的访问标签:

 1 template<class T> class Handle
 2 {
 3 public:
 4     Handle(T *p = 0);
 5     Handle(const Handle& h);
 6     Handle& operator=(const Handle&);
 7     ~Handle();
 8     //other member functions
 9 protected:   //使派生类也可以访问此标签下的成员 
10     T* ptr;
11     CUseCount u;    //将引用计数类抽象
12 };

View Code

定义继承自Handle<string>的派生类：

 1 class StrHandle : public Handle<string>
 2 {
 3 public:
 4     char & operator[](int index)    //实现写时复制
 5     {
 6         if(u.makeonly())
 7             ptr = new T(*ptr);
 8         return *ptr[index];
 9     }
10 };
11 
12 int main()
13 {
14     StrHandle<string> hp(new string("Grubby"));
15     StrHandle<string> hp2(hp);
16     char c = hp[3];
17     c = 'e';
18 
19     return 0;
20 }

View Code

　　文中提到的两种实现写时复制方法都比较复杂，不是很直观，添加了很多额外的代码，文中实现的句柄类中引用计数和T类型指针是分开的，而如果将这两个成员封装在一起的话呢？

　　未完待续……

posted on 2014-10-22 01:15 Tourun 阅读(1102) 评论(0) 编辑收藏举报

刷新页面返回顶部