奇特递归模板模式

 有些时候需要对一个类新添加的对象进行计数，这个估计很多人都会，所有工作就是添加静态成员、修改构造函数和析构函数而已。但有时候又会有一些麻烦的事发生，就是想对一个类家族的每一个类都进行单独计数时，难道每个类单独添加这样的工作么，这样的工作量也未免太大了吧？但是采用从基类继承下来的方法又会有另一个问题出现，下面看看代码：

01 //: C05:CountedClass2.cpp
02 // Erroneous attempt to count objects.
03 #include <iostream>
04 using namespace std;
05 class Counted {
06 static int count;
07 public:
08 Counted() { ++count; }
09 Counted(const Counted&) { ++count; }
10 ~Counted() { --count; }
11 static int getCount() { return count; }
12 };
13 int Counted::count = 0;
14 class CountedClass : public Counted {};
15 class CountedClass2 : public Counted {};
16 int main() {
17 CountedClass a;
18 cout << CountedClass::getCount() << endl;    // 1
19 CountedClass b;
20 cout << CountedClass::getCount() << endl;    // 2
21 CountedClass2 c;
22 cout << CountedClass2::getCount() << endl;   // 3 (Error)
23 } ///:~

这种情况下是为派生自Counted所有类进行计数，而不是我们要的对每个派生自Counted单独进行计数，因为派生自Counted的所有类都共享了相同且唯一的静态数据成员。这时要怎么办，难道要自己为每个类都进行重复的工作么？其实一种奇特的模板构造实现了这种方式，如下：

 

01  //: C05:CountedClass3.cpp
02  #include <iostream>
03  using   namespace   std ;
04  template < class   T >   class   Counted   {
05  static   int   count ;
06  public :
07  Counted ()   {   ++ count ;   }
08  Counted ( const   Counted < T >& )   {   ++ count ;   }
09  ~ Counted ()   {   -- count ;   }
10  static   int   getCount ()   {   return   count ;   }
11  };
12  template < class   T >   int   Counted < T >:: count   =   0 ;
13  // Curious class definitions
14  class   CountedClass   :   public   Counted < CountedClass >   {};
15  class   CountedClass2   :   public   Counted < CountedClass2 >   {};
16  int   main ()   {
17  CountedClass   a ;
18  cout   <<   CountedClass :: getCount ()   <<   endl ;      // 1
19  CountedClass   b ;
20  cout   <<   CountedClass :: getCount ()   <<   endl ;      // 2
21  CountedClass2   c ;
22  cout   <<   CountedClass2 :: getCount ()   <<   endl ;     // 1 (!)
23 
24  }   ///:~

 

这样的话每个类都派生于一个唯一的基类，这个基类将它本身（派生类）作为模板参数！它看起来似乎是很奇怪的用法，好像陷入了一个递归的定义。其实由于Counted的数据成员不依赖于类型T，当模板被解析的时候，Counted的大小就可以知道了（这个可以试下用不同的类型参数来实例化Counted，会发现Counted的大小总是相同的）。因此实际上用什么样的参数来实例化Countd无关紧要，因为它的大小总是相同的。当它被解析时，用任意一个Counted实例的派生类当然也就可以了。现在因为每个类都派生自唯一的基类，所以都有属于自己的静态数据，这样就可以对每个派生类进行单独的计数了，而避免了重复的添加工作。