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

 1 #include <iostream>
 2 using namespace std;
 3 
 4 template<typename T>
 5 struct m_plus
 6 {
 7     T operator()(const T& x, const T& y) { return x + y; }
 8 };
 9 
10 int main(int argc, char *argv[])
11 {
12     // 定义其对象  调用其operator()
13     m_plus<int> op;
14     cout << op(1, 2) << endl;
15     // 产生一个匿名对象  这是仿函数的主流用法
16     cout << m_plus<int>()(1, 2) << endl;
17     return 0;
18 }

 1 #include <iostream>
 2 using namespace std;
 3 
 4 template<typename T, T add>
 5 struct m_plus
 6 {
 7     m_plus() { _add = add; }
 8     T operator()(const T& x) { return x + _add; }
 9     // 仿函数可以具有自己的状态
10     int _add;
11 };
12 
13 int main(int argc, char *argv[])
14 {
15     m_plus<int, 10> op;
16     cout << op(100) << endl;
17     cout << op(200) << endl;
18     return 0;
19 }

 1 #include <iostream>
 2 #include <vector>
 3 #include <functional>
 4 #include <algorithm>
 5 using namespace std;
 6 
 7 
 8 int main(int argc, char *argv[])
 9 {
10     vector<int> coll{ 1, 3, 5, 7, 9, 11, 13, 15 };
11     // 接着下面有bind2nd的具体实现
12     cout << count_if(coll.begin(), coll.end(), bind2nd(greater<int>(), 10)) << endl;
13     return 0;
14 }

 1 template <class Arg1, class Arg2, class Result>
 2 struct binary_function {
 3     typedef Arg1 first_argument_type;
 4     typedef Arg2 second_argument_type;
 5     typedef Result result_type;
 6 };   
 7 
 8 template <class T>
 9 struct greater : public binary_function<T, T, bool> {
10     bool operator()(const T& x, const T& y) const { return x > y; }
11 };

 1 template <class Operation, class T>
 2 inline binder2nd<Operation> bind2nd(const Operation& op, const T& x) {
 3     typedef typename Operation::second_argument_type arg2_type;
 4     // 调用binder2nd
 5     return binder2nd<Operation>(op, arg2_type(x));
 6 }
 7 
 8 // binder2nd是一个一元仿函数(本身可以搭配函数适配器一起使用)
 9 template <class Operation> 
10 class binder2nd
11   : public unary_function<typename Operation::first_argument_type,
12                           typename Operation::result_type> 
13 {
14 protected:
15     // 传进来的二元仿函数
16     Operation op;
17     // 传进来的第二个参数  因为仿函数内部可以typedef  而函数指针则不行
18     // 因此只能适配仿函数  而不能适配函数指针
19     typename Operation::second_argument_type value;
20 public:
21     // 构造函数
22     binder2nd(const Operation& x,
23             const typename Operation::second_argument_type& y) 
24        : op(x), value(y) {}
25 
26     // 直接调用二元仿函数 
27     typename Operation::result_type
28     operator()(const typename Operation::first_argument_type& x) const {
29         return op(x, value); 
30     }
31 };