【转】C++实用技巧（三）

今天是关于内存的最后一篇了。上一篇文章讲了为什么不能对一个东西随便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使用。