C++中的标准函数对象

1. 函数对象
2. 函数对象是一种利用句法规则特定设计的类生成的对象,它的作用类似于函数。
3. 在C++中，这是通过在类中定义成员函数operator()实现的，举个例子：
4. struct myclass {
5.     int operator()(int a) {return a;}
6. }myobject;
7. int x = myobject(0);
8. 它们作为断定或者比较功能和标准算法(algorithms)一起使用时将非常有用。
9. 在头文件<functional>中标准库提供了好几种标准的函数对象和一些修改方法以适应它们自己的行为。
10. 基类
11. unary_function  一元的函数对象基类
12. template <class Arg, class Result>
13.   struct unary_function {
14.     typedef Arg argument_type;
15.     typedef Result result_type;
16.   };
17. binary_function 二元的函数对象基类
18. template <class Arg1, class Arg2, class Result>
19.   struct binary_function {
20.     typedef Arg1 first_argument_type;
21.     typedef Arg2 second_argument_type;
22.     typedef Result result_type;
23.   };
25. 算子类
26. 算术操作符
27. plus        +   加函数对象类  
28. template <class T> struct plus : binary_function <T,T,T> {
29.   T operator() (const T& x, const T& y) const
30.     {return x+y;}
31. };
32. minus       -   减函数对象类
33. 同理，这里就不一一列举
34. multiplies  *   乘函数对象类
35. divides     /   除函数对象类
36. modulus     %   模函数对象类
37. negate      -   负函数对象类
39. 比较操作符
40. equal_to    ==  函数对象类用于相等比较
41. template <class T> struct equal_to : binary_function <T,T,bool> {
42.   T operator() (const T& x, const T& y) const
43.     {return x==y;}
44. };
45. not_equal_to    !=  函数对象类用于不相等比较
46. 同理，这里就不一一列举
47. greater     >   函数对象类用于大于比较
48. less        <   函数对象类用于小于比较
49. greater_equal   >=  函数对象类用于不小于比较
50. less_equal  <=  函数对象类用于不大于比较
52. 逻辑操作符
53. logical_and &&  逻辑与函数对象类
54. logical_or  ||  逻辑或函数对象类
55. logical_not !   逻辑非函数对象类
57. 适配器和转换功能
58. 否定器
59. not1    返回一元函数对象的反面
60. template <class Predicate>
61. unary_negate<Predicate> not1 (const Predicate& pred)
62. {
63.   return unary_negate<Predicate>(pred);
64. }
65. not2    返回二元函数对象的方面
66. template <class Predicate>
67. binary_negate<Predicate> not2 (const Predicate& pred)
68. {
69.   return binary_negate<Predicate>(pred);
70. }
72. 参数绑定器
73. bind1st     返回绑定了第一个参数的函数对象
74. template <class Operation, class T>
75. binder1st<Operation> bind1st (const Operation& op, const T& x)
76. {
77.   return binder1st<Operation>(op, typename Operation::first_argument_type(x));
78. }
79. bind2nd     返回绑定了第二个参数的函数对象
80. template <class Operation, class T>
81. binder2nd<Operation> bind2nd (const Operation& op, const T& x)
82. {
83.   return binder2nd<Operation>(op, typename Operation::second_argument_type(x));
84. }
86. 有用的类型
87. unary_negate    生成一元函数对象类的反面
88. template <class Predicate> class unary_negate
89.   : public unary_function <typename Predicate::argument_type,bool>
90. {
91. protected:
92.   Predicate fn;
93. public:
94.   explicit unary_negate ( const Predicate& pred ) : fn (pred) {}
95.   bool operator() (const typename Predicate::argument_type& x) const
96.   { return !fn(x); }
97. };
98. binary_negate   生成二元函数对象类的反面
99. template <class Predicate> class binary_negate
100.   : public binary_function <typename Predicate::first_argument_type,
101.                             typename Predicate::second_argument_type, bool>
102. {
103. protected:
104.   Predicate fn;
105. public:
106.   explicit binary_negate ( const Predicate& pred ) : fn (pred) {}
107.   bool operator() (const typename Predicate::first_argument_type& x,
108.                    const typename Predicate::second_argument_type& y) const
109.   { return !fn(x,y); }
110. };
111. binder1st   绑定了第一个参数的函数对象类
112. template <class Operation> class binder1st
113.   : public unary_function <typename Operation::second_argument_type,
114.                            typename Operation::result_type>
115. {
116. protected:
117.   Operation op;
118.   typename Operation::first_argument_type value;
119. public:
120.   binder1st ( const Operation& x,
121.               const typename Operation::first_argument_type& y) : op (x), value(y) {}
122.   typename Operation::result_type
123.     operator() (const typename Operation::second_argument_type& x) const
124.     { return op(value,x); }
125. };
126. binder2nd   绑定了第二个参数的函数对象类
127. template <class Operation> class binder2nd
128.   : public unary_function <typename Operation::first_argument_type,
129.                            typename Operation::result_type>
130. {
131. protected:
132.   Operation op;
133.   typename Operation::second_argument_type value;
134. public:
135.   binder2nd ( const Operation& x,
136.               const typename Operation::first_argument_type& y) : op (x), value(y) {}
137.   typename Operation::result_type
138.     operator() (const typename Operation::first_argument_type& x) const
139.     { return op(x,value); }
140. };
142. 还有一小部分没有翻译(这部分我还没看呢)，以后另起补上。