在C++中计算物件个数（Objects Counting in C++）

原文出自：More Effective C++ 电子版 p.452 

仅为个人学习，暴露缺点；所以仅供参考，欢迎讨论！

 

需求：当我需要实时了解当前有多少类型的对象同时存在。

设计：比如一开始会这样设计

  
    

   
     
   
     class
   
      Widget { 

   
     public
   
     : 
 Widget() { 
   
     ++
   
     count; } 
 Widget(
   
     const
   
      Widget
   
     &
   
     ) { 
   
     ++
   
     count; } 
 
   
     ~
   
     Widget() { 
   
     --
   
     count; } 
 
   
     static
   
      size_t howMany() { 
   
     return
   
      count; } 


   
     private
   
     : 
 
   
     static
   
      size_t count; 
}; 
  
    

 

直接在类中增加一个static member data。然后当Widget类型有对象被构造（复制构造）时计数器+1，析构时计数器-1；如果目标仅仅是针对Widget类的话，我们的需求已经被达到了。

但是，当我们需要统计不同类型的对象个数时，就需要换一种更为舒服的实现方式了。

设计一个计数类：

  
    

   
     
   
     class
   
      Counter { 

   
     public
   
     : 
 Counter() { 
   
     ++
   
     count; } 
 Counter(
   
     const
   
      Counter
   
     &
   
     ) { 
   
     ++
   
     count; } 
 
   
     ~
   
     Counter() { 
   
     --
   
     count; } 
 
   
     static
   
      size_t howMany() 
 { 
   
     return
   
      count; } 

   
     private
   
     : 
 
   
     static
   
      size_t count; 
}; 
  
    

 

  
    

   
     
   
     //
   
      在需要计数的 class 中内嵌一个Counter object。 
   
     

   
     class
   
      Widget { 

   
     public
   
     : 
 ..... 
   
     //
   
      Widget 该有的所有public 成员， 
 
   
     //
   
      都放在这里。 
   
     

   
      
   
     static
   
      size_t howMany() 
 { 
   
     return
   
      Counter::howMany(); } 

   
     private
   
     : 
 ..... 
   
     //
   
      Widget 该有的所有private 成员， 
 
   
     //
   
      都放在这里。 
   
     

   
      Counter c; 
}; 


   
     //
   
      另一个方法是把Counter 当做base class，像这样： 

   
     //
   
      让需要计数的class 继承自Counter 
   
     

   
     class
   
      Widget: 
   
     public
   
      Counter { 
 ..... 
   
     //
   
      Widget 该有的所有public 成员， 
 
   
     //
   
      都放在这里。 
   
     

   
     private
   
     : 
 ..... 
   
     //
   
      Widget 该有的所有private 成员， 
 
   
     //
   
      都放在这里。 
   
     

   
     }; 
  
    

 

但是这样设计的话又会出现一个问题，看出来了么？

对，就是static的count。如果我们同时存在A类和B类需要计数，那我们则需要2个static size_t count，而不是一个！

运用C++ 中最广为人知但名称十分诡异的一个技俩：

  
    

   
     
   
     template 
   
     <
   
     class
   
      T
   
     >
   
     

   
     class
   
      Counter {

   
     public
   
     :
 Counter() { 
   
     ++
   
     count; }
 Counter(
   
     const
   
      Counter
   
     &
   
      rhs){ 
   
     ++
   
     count; }
 
   
     virtual
   
      
   
     ~
   
     Counter() { 
   
     --
   
     count; }
 
   
     static
   
      size_t hMany() { 
   
     return
   
      count; }

   
     private
   
     :
 
   
     static
   
      size_t count;
};

template 
   
     <
   
     class
   
      T
   
     >
   
     
size_t Counter
   
     <
   
     T
   
     >
   
     ::count 
   
     =
   
      
   
     0
   
     ;
  
    

 

现在，Counter 成了一个 template，不论内嵌式设计或继承式 设计，都可以运作了。

  
    

   
     
   
     class
   
      Widget : 
   
     private
   
      Counter
   
     <
   
     Widget
   
     >
   
      
{

   
     public
   
     :
 
   
     using
   
      Counter
   
     <
   
     Widget
   
     >
   
     ::hMany;
 
   
     static
   
      size_t getCount() { 
   
     return
   
      Counter
   
     <
   
     Widget
   
     >
   
     ::hMany(); }
};

   
     class
   
      AnotherWidget : 
   
     public
   
      Counter
   
     <
   
     AnotherWidget
   
     >
   
      
{

   
     public
   
     :
 
   
     static
   
      size_t getCount() { 
   
     return
   
      Counter
   
     <
   
     AnotherWidget
   
     >
   
     ::hMany(); }
};



   
     int
   
      main()
{
 cout 
   
     <<
   
      
   
     sizeof
   
     (Widget) 
   
     <<
   
      endl;
 cout 
   
     <<
   
      
   
     sizeof
   
     (AnotherWidget) 
   
     <<
   
      endl;

 Widget a,b,c,d,e,f;
 cout 
   
     <<
   
      f.getCount()
   
     <<
   
      endl;
 AnotherWidget x,y,z;
 x
   
     =
   
     z;
 AnotherWidget h 
   
     =
   
      z;
 cout
   
     <<
   
      z.getCount()
   
     <<
   
     endl;
 
   
     return
   
      
   
     0
   
     ;
}