随笔-341  评论-2670  文章-0  trackbacks-0

    复杂的东西写多了,如今写点简单的好了。由于功能上的需要,Vczh Library++3.0被我搞得很离谱。为了开发维护的遍历、减少粗心犯下的错误以及增强单元测试、回归测试和测试工具,因此记录下一些开发上的小技巧,以便抛砖引玉,造福他人。欢迎高手来喷,菜鸟膜拜。

    今天是关于内存的最后一篇了。上一篇文章讲了为什么不能对一个东西随便memset。里面的demo代码出了点小bug,不过我不喜欢在发文章的时候里面的demo代码也拿去编译和运行,所以大家有什么发现的问题就评论吧。这样也便于后来的人不会受到误导。这次说的仍然是构造函数和析构函数的事情,不过我们将通过亲手开发一个智能指针的方法,知道引用计数如何帮助管理资源,以及错误使用引用计数的情况。

    首先先来看一下智能指针是如何帮助我们管理内存的。现在智能指针的实现非常多,我就假设这个类型叫Ptr<T>吧。这跟Vczh Library++ 3.0所使用的实现一样。

 1 class Base
 2 {
 3 public:
 4   virtual ~Base(){}
 5 };
 6 
 7 class Derived1 : public Base
 8 {
 9 };
10 
11 class Derived2 : public Base
12 {
13 };
14 
15 //---------------------------------------
16 
17 List<Ptr<Base>> objects;
18 objects.Add(new Derived1);
19 objects.Add(new Derived2);
20 
21 List<Ptr<Base>> objects2;
22 objects2.Add(objects[0]);

    当然这里的List也是Vczh Library++3.0实现的,不过这玩意儿跟vector也好跟C#的List也好都是一个概念,因此也就不需要多加解释了。我们可以看到智能指针的一个好处,只要没有循环引用出现,你无论怎么复制它,最终总是可以被析构掉的。另一个例子告诉我们智能指针如何处理类型转换:
1 Ptr<Derived1> d1=new Derived1;
2 Ptr<Base> b=d1;
3 Ptr<Derived2> d2=b.Cast<Derived2>();
4 // d2是空,因为b指向的是Derived1而不是Derived2。

    这就如同我们Derived1*可以隐式转换到Base*,而当你使用dynamic_cast<Derived2*>(static_cast<Base*>(new Derived1))会得到0一样。智能指针在帮助我们析构对象的同时,也要做好类型转换的工作。

    好了,现在先让我们一步一步做出那个Ptr<T>。我们需要清楚这个智能指针所要实现的功能是什么,然后我们一个一个来做。首先让我们列出一张表:
    1、没有参数构造的时候,初始化为空
    2、使用指针构造的时候,拥有那个指针,并且在没有任何智能指针指向那个指针的时候删除掉该指针。
    3、智能指针进行复制的时候,两个智能指针共同拥有该内部指针。
    4、智能指针可以使用新的智能指针或裸指针重新赋值。
    5、需要支持隐式指针类型转换,static_cast不支持而dynamic_cast支持的转换则使用Cast<T2>()成员函数来解决。
    6、如果一个裸指针直接用来创建两个智能指针的话,期望的情况是当两个智能指针析构掉的时候,该指针会被delete两次从而崩溃。
    7、不处理循环引用。

    最后两点实际上是错误使用智能指针的最常见的两种情况。我们从1到5一个一个实现。首先是1。智能指针可以隐式转换成bool,可以通过operator->()拿到内部的T*。在没有使用参数构造的时候,需要转换成false,以及拿到0:
 1 template<typename T>
 2 class Ptr
 3 {
 4 private:
 5   T* pointer;
 6   int* counter;
 7 
 8   void Increase()
 9   {
10     if(counter)++*counter;
11   }
12 
13   void Decrease()
14   {
15     if(counter && --*counter==0)
16     {
17       delete counter;
18       delete pointer;
19       counter=0;
20       pointer=0;
21     }
22   }
23 
24 public:
25   Ptr():pointer(0),counter(0)
26   {
27   }
28 
29   ~Ptr()
30   {
31     Decrease();
32   }
33 
34   operator bool()const
35   {
36     return counter!=0;
37   }
38 
39   T* operator->()const
40   {
41     return pointer;
42   }
43 };

    在这里我们实现了构造函数和析构函数。构造函数把内部指针和引用计数的指针都初始化为空,而析构函数则进行引用计数的减一操作。另外两个操作符重载很容易理解。我们主要来看看Increase函数和Decrease函数都分别做了什么。Increase函数在引用计数存在的情况下,把引用计数加一。而Decrease函数在引用计数存在的情况下,把引用计数减一,如果引用计数在减一过程中变成了0,则删掉拥有的资源。

    当然到了这个时候智能指针还不能用,我们必须替他加上复制构造函数,operator=操作符重载以及使用指针赋值的情况。首先让我们来看使用指针赋值的话我们应该加上什么:
 1   Ptr(T* p):pointer(0),counter(0)
 2   {
 3     *this=p;
 4   }
 5 
 6   Ptr<T>& operator=(T* p)
 7   {
 8     Decrease();
 9     if(p)
10     {
11       pointer=p;
12       counter=new int(1);
13     }
14     else
15     {
16       pointer=0;
17       counter=0;
18     }
19     return *this;
20   }

    这里还是偷工减料了的,构造函数接受了指针的话,还是转给operator=去调用了。当一个智能指针被一个新指针赋值的时候,我们首先要减掉一个引用计数,因为原来的指针再也不被这个智能指针共享了。之后就进行判断,如果来的是0,那么就变成空。如果不是0,就拥有该指针,引用计数初始化成1。于是我们就可以这么使用了:
1 Ptr<Base> b=new Derived1;
2 Ptr<Derived2> d2=new Derived2;

    让我们开始复制他们吧。复制的要领是,先把之前拥有的指针脱离掉,然后连接到一个新的智能指针上面去。我们知道非空智能指针有多少个,总的引用计数的和就是多少,只是分配到各个指针上面的数字不一样而已:
 1   Ptr(const Ptr<T>& p):pointer(p.pointer),counter(p.counter)
 2   {
 3     Increase();
 4   }
 5 
 6   Ptr<T>& operator=(const Ptr<T>& p)
 7   {
 8     if(this!=&p)
 9     {
10       Decrease();
11       pointer=p.pointer;
12       counter=p.counter;
13       Increase();
14     }
15     return *this;
16   }

    在上一篇文章有朋友指出重载operator=的时候需要考虑是不是自己赋值给自己,其实这是很正确的。我们写每一类的时候,特别是当类拥有自己控制的资源的时候,需要非常注意这件事情。当然如果只是复制几个对象而不会new啊delete还是close什么handle,那检查不检查也无所谓了。在这里我们非常清楚,当增加一个新的非空智能指针的时候,引用计数的总和会加一。当修改一个非空智能指针的结果也是非空的时候,引用计数的和保持不变。当然这是应该的,因为我们需要在所有非空智能指针都被毁掉的时候,释放受保护的所有资源。

    到了这里一个智能指针基本上已经能用了,但是还不能处理父类子类的情况。这个是比较麻烦的,一个Ptr<Derived>事实上没有权限访问Ptr<Base>的内部对象。因此我们需要通过友元类来解决这个问题。现在让我们来添加两个新的函数吧,从一个任意的Ptr<C>复制到Ptr<T>,然后保证只有当C*可以隐式转换成T*的时候编译能够通过:
 1   template<X> friend class Ptr;
 2 
 3   template<typename C>
 4   Ptr(const Ptr<C>& p):pointer(p.pointer),counter(p.counter)
 5   {
 6     Increase();
 7   }
 8 
 9   template<typename C>
10   Ptr<T>& operator=(const Ptr<C>& p)
11   {
12     Decrease();
13     pointer=p.pointer;
14     counter=p.counter;
15     Increase();
16     return *this;
17   }

    注意这里我们的operator=并不用检查是不是自己给自己赋值,因为这是两个不同的类,相同的话会调用上面那个operator=的。如果C*不能隐式转换到T*的话,这里的pointer=p.pointer就会失败,从而满足了我们的要求。

    现在我们能够做的事情就更多了:
1 Ptr<Derived1> d1=new Derived1;
2 Ptr<Base> b=d1;

    于是我们只剩下最后一个Cast函数了。这个函数内部使用dynamic_cast来做判断,如果转换失败,会返回空指针:
 1   tempalte<typename C>
 2   Ptr<C> Cast()const
 3   {
 4     C* converted=dynamic_cast<C*>(pointer);
 5     Ptr<C> result;
 6     if(converted)
 7     {
 8       result.pointer=converted;
 9       result.counter=counter;
10       Increase();
11     }
12     return result;
13   }

    这是一种hack的方法,平时是不鼓励的……不过因为操作的都是Ptr,而且特化Ptr也是使用错误的一种,所以这里就不管了。我们会检查dynamic_cast的结果,如果成功了,那么会返回一个非空的新智能指针,而且这个时候我们也要记住Increase一下。

    好了,基本功能就完成了。当然一个智能指针还要很多其他功能,譬如说比较什么的,这个就你们自己搞定哈。

    指针和内存就说到这里了,下一篇讲如何利用一个好的IDE构造轻量级单元测试系统。我们都说好的工具能够提高生产力,因此这种方法不能脱离一个好的IDE使用。
posted on 2010-06-24 15:03 陈梓瀚(vczh) 阅读(8532) 评论(15)  编辑 收藏 引用 所属分类: C++实用技巧

评论:
# re: C++实用技巧(三) 2010-06-25 15:22 | zuhd
全文可以理解为一段共享内存的故事  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-25 21:31 | SonicLing
效率存在问题。
12 counter=new int(1);
感觉这个new完全没必要啊。

而且Ptr<T>的值传递会很慢,完全没有了指针的速度啊。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-25 21:41 | 陈梓瀚(vczh)
@SonicLing
我不会为了不是瓶颈部分的效率而让开发效率大大下降的。加班的原因还不是因为程序写得慢。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-25 21:42 | 陈梓瀚(vczh)
@SonicLing
这个new有必要,counter==1也是要有counter的。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-25 22:17 | SonicLing
@陈梓瀚(vczh)
我的意思是直接用int counter,而不是指针。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-26 09:48 | zuhd
@SonicLing


全文可以理解为一段共享内存的故事

你显然没有理解这段话的意思  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-26 12:02 | 陈梓瀚(vczh)
@SonicLing
那一共有三个Ptr,其中一个死了,你不可能同时改了另外两个的counter。谢谢。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-26 23:58 | SonicLing
@陈梓瀚(vczh)
恩,我理解错了。我写过类似的指针,只不过把counter放在对象里,共享对象同时也共享了counter,这样在传递和内存分配方面效率高一点,成员只包含一个指针,优化收益也高一些,免去了过多的new/delete。因为跟你一样,也在写编译/解释器,所以非常看重效率。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-27 00:10 | 陈梓瀚(vczh)
@SonicLing
T显然是任意的,你不能修改。所以这才是我分出来的原因。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-27 00:10 | 陈梓瀚(vczh)
@SonicLing
虚拟机效率高就好了,编译器没必要。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-27 09:52 | 饭中淹
为什么不把pointer和counter放在一个结构里,new这个结构?
我做这个东西的时候,就是做这样一个core_struct,然后加一个core_struct池来维护内存。所有的Ptr传递和保存的就是这个core_struct的指针。  回复  更多评论
  
# re: C++实用技巧(三) 2010-06-27 13:02 | 陈梓瀚(vczh)
@饭中淹
你这种做法在遇到类型转换的时候就有问题了。  回复  更多评论
  
# re: C++实用技巧(三) 2010-07-01 16:32 |
使用type_traits模板技术可以非常漂亮的解决智能指针的子父类转换问题,如果要安全转换子父类指针,根本办法是打开RTTI,在智能指针实现的内部使用dynamic_cast,并在出错时抛出异常。
但是RTTI我只建议在个别模块中使用,这样不会影响别的模块的对象内存结构,这种结构会占用多余的内存。  回复  更多评论
  
# re: C++实用技巧(三) 2010-07-01 17:06 | 陈梓瀚(vczh)
@酿
我这不就这么做吗,请认真阅读。话说回来,RTTI在不是瓶颈的时候,我绝对不关掉它。  回复  更多评论
  
# re: C++实用技巧(三) 2014-10-30 16:15 | 大花猫
Ptr<T>& operator=(T* p)这个函数怎么没有检查自赋值  回复  更多评论
  

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理