STL中的binder

 1 #include <functional>
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 int main(int argc, char *argv[])
 7 {
 8     binder1st<greater<int> > big = bind1st(greater<int>(), 3);
 9     int value = 4;
10 
11     if (big(value))
12     {
13         cout<<"Greater than "<<value<<endl;
14     }
15     else
16     {
17         cout<<"Not Greater than "<<value<<endl;
18     }
19 
20     return 0;
21 }

见上面实用STLbinder的实例代码，其中关键是

1 binder1st<greater<int> > big = bind1st(greater<int>(), 3);

这一句，其中拆开来，是由以下几个部分组成

greater<int>()是将greater<int>::operator()传给bind1st()（之前错误以为是构造了一个临时的对象，纠正一下！！！）
binder1st<greater<int> > big是定义一个binder1st对象，用于保存bind1st()返回的binder1st对象，该对象即是对greater<int>::operator()绑定第一个参数之后获得另一个functor。
由于greater是binary_function，本身有2个入参，如此绑定之后获得第一个如参就被固定成bind1st()第二个参数中给的值（这里是3），那么调用big(value)，就相当于调用greater<int>(3, value)，即达到绑定的作用

如此理解了STL binder的实用方法之后，进一步剖析一下binder的实现，以bind1st为例，其定义很简单，如下

1 template<typename _Operation, typename _Tp>
2 inline binder1st<_Operation>
3 bind1st(const _Operation& __fn, const _Tp& __x)
4 {
5   typedef typename _Operation::first_argument_type _Arg1_type;
6   return binder1st<_Operation>(__fn, _Arg1_type(__x));
7 }

 1   template<typename _Operation>
 2     class binder1st
 3     : public unary_function<typename _Operation::second_argument_type,
 4                 typename _Operation::result_type>
 5     {
 6     protected:
 7       _Operation op;
 8       typename _Operation::first_argument_type value;
 9 
10     public:
11       binder1st(const _Operation& __x,
12         const typename _Operation::first_argument_type& __y)
13       : op(__x), value(__y) { }
14 
15       typename _Operation::result_type
16       operator()(const typename _Operation::second_argument_type& __x) const
17       { return op(value, __x); }
18 
19       // _GLIBCXX_RESOLVE_LIB_DEFECTS
20       // 109.  Missing binders for non-const sequence elements
21       typename _Operation::result_type
22       operator()(typename _Operation::second_argument_type& __x) const
23       { return op(value, __x); }
24     }

bind1st第一个参数是一个仿函数对象，就比如functional里预定义的greater、plus之类的binder系列类，这些类都是继承了

 1   template<typename _Arg1, typename _Arg2, typename _Result>
 2     struct binary_function
 3     {
 4       /// @c first_argument_type is the type of the first argument
 5       typedef _Arg1     first_argument_type; 
 6 
 7       /// @c second_argument_type is the type of the second argument
 8       typedef _Arg2     second_argument_type;
 9 
10       /// @c result_type is the return type
11       typedef _Result     result_type;
12     };

这些仿函数类中都因此有了first_argument_type、second_argment_type和result_type的类型定义，而STL的binder即是利用这些预定义的类型。所以当需要自己定义给STL binder使用的仿函数类时，就必须继承binary_function以满足binder的需求。

==================================

现在发现boost/tr1的bind/function更为强大，好用！！！！——2014-03-27