在用C++写一个函数的时候，发现其中需要对很多个类似的变量进行类似的处理，如：

  1. if (map.exists(var1.getName()) {  
  2.     process(map.get(var1.getName()));  
  3. } 

程序中有很多个类似var的变量，而且都不在数组中。因此只能一个个的使用上述语句进行处理。为了简体代码，也为了代码的复用性，这里想到了4种办法，各有优劣。

1. 定义私有成员函数

　　定义一个private的成员函数来处理。由于处理语句较少，为了提高处理效率，这个私有成员函数可以定义成inline的。例：

  1. // @(#) MyClass.h  
  2. class MyClass ...{  
  3.     // ......  
  4. private:  
  5.     void handle(Type& var) ...{  
  6.         if (map.exists(var.getName()) ...{  
  7.             process(map.get(var.getName());  
  8.         }  
  9.     }  
  10. };  
  11.  
  12. // @(#) MyClass.cpp  
  13. void MyClass::Handling(void) ...{  
  14.     // ......  
  15.     handle(var1);  
  16.     handle(var2);  
  17.     // ...  
  18.     handle(varn);  
  19. }  

这是最常见的做法。但使用这个方法，如果定义成inline函数，则代码会出现在头文件中，没能很好的隐藏。如果不定义为inline函数，对效率又有影响。当然，优点也是显而易见的，这个方法最容易想到，这是其一。其二，使用这个方法，代码看起来会比较整洁。

2. 定义当前编译单元内的全局函数

　　为了克服第1种方法中的缺点，不难想到——如果将这个处理函数定义在MyClass.cpp中，不作为成员函数定义。问题不是就解决了吗？为了在其它代码文件中隐藏这个函数（不让其它cpp文件中的函数调用它），还可以将其申明为static的。于是：

  1. // @(#) MyClass.cpp  
  2. inline static void handle(Type& var) ...{  
  3.     if (map.exists(var.getName()) ...{  
  4.         process(map.get(var.getName());  
  5.     }  
  6. }  
  7.  
  8. void MyClass::Handling(void) ...{  
  9.     // ......  
  10.     ::handle(var1);  
  11.     ::handle(var2);  
  12.     // ...  
  13.     ::handle(varn);  
  14. }  

这样的确很好的解决了隐藏代码的问题，同时也解决了效率的问题。但是，handle函数是一个仅仅用于MyClass::Handling中的临时函数，却定义在MyClass::Handling之外。如果有一天不再需要MyClass::Handling而将它删除的时候，很容易忘记删除handle函数的。这些代码中就会留下垃圾代码（即没有任何作用的代码）了。

　　于是，又想到了另一个方案——

3. 在函数中定义宏并在使用后取消定义

　　在函数体内使用#define定义一个临时的宏进行上述处理。，并在处理所有变量之后，函数结束前，使用#undefine取消对该宏的定义。这样，相当于由编译器展开宏来实现了这些语句的录入。例：

  1. // @(#) MyClass.cpp  
  2. void MyClass::Handling(void) ...{  
  3.     // .....  
  4. #define __HANDLE(VAR)   
  5.     if (map.Exists(VAR.getName())   
  6.     Process(map.get(VAR.getName());  
  7.  
  8.     __HANDLE(var1);  
  9.     __HANDLE(var2);  
  10.     // ...  
  11.     __HANDLE(varn);  
  12. #undef __HANDLE  
  13. } 

这样虽然把代码搞得有点不太整洁，但也不失为一个解决方案，只是——如果在别处也有定义__HANDLE宏，#undefine岂不是把那个宏取消掉了，会不会造成以后的代码出问题呢？要是能在函数内定义函数就好了。可惜C++没有提供在函数内定义函数的特性，倒是有个类似的东西——局部类。

4. 定义局部类

　　局部类就是定义在函数内部的类。局部类和普通的类相似，但不能拥有静态成员。局部类可以访问其外部函数中的静态变量，但不能访问其普通变量。如果改用静态类，代码如下：

  1. // @(#) MyClass.cpp  
  2. void MyClass::Handling(void) ...{  
  3.     // ......  
  4.     class T ...{  
  5.     public:  
  6.         T(MapType& map) : m_Map(map) ...{}  
  7.         void handle(Type& var) ...{  
  8.             if (m_Map.exists(var.getName()) ...{  
  9.                 process(m_Map.get(var.getName());  
  10.             }  
  11.         }  
  12.     private:  
  13.         MapType& m_Map;  
  14.     } t(map);  
  15.  
  16.     t.handle(var1);  
  17.     t.handle(var2);  
  18.     // ...  
  19.     t.handle(varn);  
  20. }  

据说C++的局部类几本上没有什么作用。实际看看上例，也会哑然失笑。上例只是为了实现一个“局部函数”，定义就写了一大堆。因为没有做过仔细的测试，也不知道其效率如何。编译时估计还得为这个局部类分配空间，实在有点得不偿失。

小结

　　只不过为了在一个函数中进行简单的批量处理，一不小心就搞了这么些东西出来。至于实际编程过程中使用哪种方法来进行批处理，就看各位自己的喜好了。