复杂的东西写多了,如今写点简单的好了。由于功能上的需要,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-23 23:03
陈梓瀚(vczh) 阅读(9818)
评论(15) 编辑 收藏 引用 所属分类:
C++实用技巧