C++实用技巧（三）

复杂的东西写多了，如今写点简单的好了。由于功能上的需要，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使用。

from: http://www.cppblog.com/vczh/archive/2010/06/24/118635.html