【导读】：在我们日常编码中会发现有些功能代码，会不断的在不同的成员函数中用到，但是又不好将这些代码独立成一个成员函数。解决办法之一就是写一个公共的函数，不过函数用到的一些变量，就可能会成为全局变量。再说为了复用这么一段代码，就要单立出一个函数，也不是很好维护。此时就可以用到仿函数了。

' E$ _- t7 f7 K: ]% H. a3 a2 q7 B2 X* T9 L* p

以下是正文

---

引入仿函数（functor）原因

先考虑一个简单的例子：假设有一个vector<string>，你的任务是统计长度小于5的string的个数，如果使用count_if函数的话，你的代码可能长成这样：

1. 
   
2. bool LengthIsLessThanFive(const string& str)
   ( ?8 H" O+ [$ q( T7 g2 ~: f
3. {
   
4.     return str.length() < 5;   
   
5. }
   3 C+ r# x; S$ c9 a
6. int res=count_if(vec.begin(), vec.end(), LengthIsLessThanFive);

复制代码

其中count_if函数的第三个参数是一个函数指针，返回一个bool类型的值。一般的，如果需要将特定的阈值长度也传入的话，我们可能将函数写成这样：

1. 
   3 |! `6 }& m( Z- h& H. K, r% r; l
2. bool LenthIsLessThan(const string& str, int len)
   
3. {
   : C7 G2 q* u1 M' D8 d1 n
4.     return str.length() < len;
   
5. }

复制代码

8 \5 d$ M: ^" \

这个函数看起来比前面一个版本更具有一般性，但是他不能满足count_if函数的参数要求：count_if要求的是unary function（仅带有一个参数）作为它的最后一个参数。所以问题来了，怎么样找到以上两个函数的一个折中的解决方案呢？

这个问题其实可以归结于一个data flow的问题，要设计这样一个函数，使其能够access这个特定的length值，回顾我们已有的知识，有三种解决方案可以考虑：

) T/ E& A/ P1 |0 f, {. A2 G: ]

（1）函数的局部变量：

局部变量不能在函数调用中传递，而且caller无法访问。

1 [1 g8 {8 H) r/ V

（2）函数的参数：

这种方法我们已经讨论过了，多个参数不适用于count_if函数。

1 |" Z. o  e1 J9 }. x! s

（3）全局变量：

我们可以将长度阈值设置成一个全局变量，代码可能像这样：

1. 
   1 V# n; o0 {3 k
2. int maxLength;
   
3. bool LengthIsLessThan(const string& str)
   
4. {
   / N' J2 v) w) R& C; D/ o
5.     return str.length() < maxLength;
   ( o; f4 v! x( F. s3 l6 R: e4 M
6. }
   
7. int res=count_if(vec.begiin(), vec.end(), LengthIsLessThan);

复制代码

这段代码看似很不错，实则不符合规范，更重要的是，它不优雅。原因有以下几点要考虑：
5 y* _! V+ m# ~+ O) u; F& d9 a3 @5 W

  }4 G1 @3 E8 S% G! t2 k: M: C

（1）容易出错：

为什么这么说呢，我们必须先初始化maxLength的值，才能继续接下来的工作，如果我们忘了，则可能无法得到正确答案。此外，变量maxLength和函数LengthIsLessThan之间是没有必然联系的，编译器无法确定在调用该函数前是否将变量初始化，给码农平添负担。

, G. @/ C3 F' v4 c& `) [1 ]: f9 P

（2）没有可扩展性：

如果我们每遇到一个类似的问题就新建一个全局变量，尤其是多人合作写代码时，很容易引起命名空间污染（namespace polution）的问题；当范围域内有多个变量时，我们用到的可能不是我们想要的那个。

（3）全局变量的问题：

每当新建一个全局变量，即使是为了coding的便利，我们也要知道我们应该尽可能的少使用全局变量，因为它的cost很高；而且可能暗示你这里有一些待解决的优化方案。

仿函数（functor）介绍
* n4 M$ L+ ]2 U* I- G# |

说了这么多，还是要回到我们原始的那个问题，有什么解决方案呢？答案当然就是这篇blog的正题部分：仿函数。

我们的初衷是想设计一个unary function，使其能做binary function的工作，这看起来并不容易，但是仿函数能解决这个问题。

先来看仿函数的通俗定义：仿函数（functor）又称为函数对象（function object）是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载operator()运算符，举个例子：

1. 
   
2. class Func
   6 i8 W+ \; {2 ^( q) l8 g2 D
3. {
   ) R0 J8 t# z: ?8 M; M7 B5 z
4.     public:
   # d/ E3 M* t6 Z
5.         void operator() (const string& str) const
   
6. {
   * R' C3 K, Z* V- a
7.             cout<<str<<endl;
   * Z+ ^) b4 ~8 G0 v" \
8.         }
   
9. };
   
10. Func myFunc;
    + h$ }2 T! u4 P4 C
11. myFunc("helloworld!");

复制代码

# E) ^5 n9 Z/ b. e7 r0 {4 S

仿函数其实是上述解决方案中的第四种方案：成员变量。成员函数可以很自然的访问成员变量：

1. 
   
2. class Func
   
3. {
   ; ]: A# a, \7 I4 y0 T; b; d0 _: T
4.     public:
   
5.         void operator() (const string& str) const
   
6. {
   ' o# D9 ^6 [* w
7.             cout<<str<<endl;
   * A$ D7 u/ _" z6 ]0 k
8.         }
   6 x1 v1 H* h2 n* }
9. };
   
10. Func myFunc;
    ' P" p9 H2 ^1 S& c: |3 E
11. myFunc("helloworld!");

复制代码

>>>hellois world

我相信这个例子能让你体会到一点点仿函数的作用了；它既能像普通函数一样传入给定数量的参数，还能存储或者处理更多我们需要的有用信息。

让我们回到count_if的问题中去，是不是觉得问题变得豁然开朗了？

1. 
   
2. class ShorterThan
     a% v7 M7 `' C+ q" w
3. {
   
4.     public:
   
5.         explicit ShorterThan(int maxLength) : length(maxLength) {}
   
6.         bool operator() (const string& str) const
   ! B8 _1 [$ q1 W2 [7 t  w9 f
7.         {
   : t. q1 k7 P. f+ ~# D' g* k
8.             return str.length() < length;
   
9.         }
   
10.     private:
    . y5 s$ O8 ~# ?8 ]1 c2 S3 X
11.         const int length;
    * L+ D9 O0 `  z4 Q; e# e" b( w9 h
12. };
    
13. //直接调用即可
    $ ~5 P. X) v* n; `/ i  x- J3 a% w
14. count_if(myVector.begin(), myVector.end(), ShorterThan(length));

复制代码

这里需要注意的是，不要纠结于语法问题：ShorterThan(length)似乎并没有调用operator()函数？其实它调用了，创建了一个临时对象。你也可以自己加一些输出语句看一看。

这篇博文就先记到这里了，仿函数也在STL中大量涉及到，不彻底弄懂仿函数的问题看到STL源码就会一头包。后续可能再分享一些关于functor的资料和个人学习心得。

* z% d- t& u8 d2 \/ h