STL源码剖析(仿函数/bind2nd)

仿函数(functors)其实就是重载了operator()的对象。

下面简单先看看它的一个例子：

 #include <iostream>
 using namespace std;
 
 template<typename T>
 struct m_plus
 {
     T operator()(const T& x, const T& y) { return x + y; }
 };
 
 int main(int argc, char *argv[])
 {
     // 定义其对象  调用其operator()
     m_plus<int> op;
     cout << op(, ) << endl;
     // 产生一个匿名对象  这是仿函数的主流用法
     cout << m_plus<int>()(, ) << endl;
     return ;
 }

既然仿函数跟函数的用法类同，那为什么不直接使用函数指针代替呢？

个人认为有两个原因

1.仿函数可以有自己的状态，而函数指针则不行(有的使用template或者static变量可以实现)。

我们可以这样子使用仿函数：

 #include <iostream>
 using namespace std;
 
 template<typename T, T add>
 struct m_plus
 {
     m_plus() { _add = add; }
     T operator()(const T& x) { return x + _add; }
     // 仿函数可以具有自己的状态
     int _add;
 };
 
 int main(int argc, char *argv[])
 {
     m_plus<int, > op;
     cout << op() << endl;
     cout << op() << endl;
     return ;
 }

2.仿函数可以与函数适配器搭配使用。

举一个例子，例如我们如果要使用count_if算法来计算容器中大于10的元素的个数。

如果我们使用greater<int>作为判别式(二元)，而count_if只接受一个一元判别式，这时候我们就需要搭配函数适配器一起使用了。

而函数指针不能直接搭配函数适配器一起使用，具体在分析bind2nd的时候会讲到。

 #include <iostream>
 #include <vector>
 #include <functional>
 #include <algorithm>
 using namespace std;
 
 int main(int argc, char *argv[])
 {
     vector<int> coll{ , , , , , , ,  };
     // 接着下面有bind2nd的具体实现
     cout << count_if(coll.begin(), coll.end(), bind2nd(greater<int>(), )) << endl;
     return ;
 }

bind2nd

bind2nd可以将二元仿函数转化为一元仿函数，这看上去好像很神奇，其实它的实现很简单。

首先，二元仿函数会继承自binary_function，其实只是一些typedef，这些都将用于函数适配器。

 template <class Arg1, class Arg2, class Result>
 struct binary_function {
     typedef Arg1 first_argument_type;
     typedef Arg2 second_argument_type;
     typedef Result result_type;
 };   
 
 template <class T>
 struct greater : public binary_function<T, T, bool> {
     bool operator()(const T& x, const T& y) const { return x > y; }
 };

bind2nd将二元仿函数跟第二个参数型别作为模板型别，下面是具体实现：

 template <class Operation, class T>
 inline binder2nd<Operation> bind2nd(const Operation& op, const T& x) {
     typedef typename Operation::second_argument_type arg2_type;
     // 调用binder2nd
     return binder2nd<Operation>(op, arg2_type(x));
 }
 
 // binder2nd是一个一元仿函数(本身可以搭配函数适配器一起使用)
 template <class Operation>
 class binder2nd
   : public unary_function<typename Operation::first_argument_type,
                           typename Operation::result_type>
 {
 protected:
     // 传进来的二元仿函数
     Operation op;
     // 传进来的第二个参数  因为仿函数内部可以typedef  而函数指针则不行
     // 因此只能适配仿函数  而不能适配函数指针
     typename Operation::second_argument_type value;
 public:
     // 构造函数
     binder2nd(const Operation& x,
             const typename Operation::second_argument_type& y)
        : op(x), value(y) {}
 
     // 直接调用二元仿函数
     typename Operation::result_type
     operator()(const typename Operation::first_argument_type& x) const {
         return op(x, value);
     }
 };