函数适配器（function adapter）：通过不同函数适配器的绑定，组合和修饰能力，可以实现强大的功能，配合STL泛型算法完成复杂功能。
绑定（bind）
template <class _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type> {
protected:
_Operation op;
typename _Operation::first_argument_type value;
public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) {}
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const {
return op(value, __x);
}
};
template <class _Operation, class _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
bind1st函数有两个参数，被绑定参数的仿函数__fn，以及待绑定到仿函数上的参数值__x。在函数中构建并返回了binder1st对象，并设置了相应的构造参数。
binder1st类中有一个仿函数（函数对象）成员op和待绑定参数value，binder1st构造函数会用传入的仿函数类和待绑定参数来初始化其类成员op与value。
binder1st本身也是一个仿函数类（functor），在类中定义的函数调用操作符（operator()）内完成了仿函数的实际功能。该函数有一个参数__x，指定操作的第二参数。然后用调用待绑定参数类op的构造函数，并用value和__x进行初始化。返回的对象的第一个参数就被绑定到binder1st的待绑定参数成员value,以实现参数绑定的功能。
binder1st的原理与binder1st相类似。
否定（not）
template <class _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{
return unary_negate<_Predicate>(__pred);
}
template <class _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool> {
protected:
_Predicate _M_pred;
public:
explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
bool operator()(const typename _Predicate::argument_type& __x) const {
return !_M_pred(__x);
}
};
not1表示一元谓词否定，传入仿函数对象，返回与传入对象的结果相反的一元谓词仿函数对象。
not2表示二元谓词否定，传入仿函数对象，返回与传入对象的结果相反的二元谓词仿函数对象。
合成（compose）
合成的作用类似于数学中的复合函数，分为一元合成和二元合成：
一元合成：h(x)=f(g(x))
二元合成：h(x)=f(g1(x)，g2(x))
template <class _Operation1, class _Operation2>
inline unary_compose<_Operation1,_Operation2>
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}
template <class _Operation1, class _Operation2>
class unary_compose
: public unary_function<typename _Operation2::argument_type,
typename _Operation1::result_type>
{
protected:
_Operation1 _M_fn1;
_Operation2 _M_fn2;
public:
unary_compose(const _Operation1& __x, const _Operation2& __y)
: _M_fn1(__x), _M_fn2(__y) {}
typename _Operation1::result_type
operator()(const typename _Operation2::argument_type& __x) const {
return _M_fn1(_M_fn2(__x)); //在此处发挥作用
}
};
二元合成的原理和一元合成相类型。
binary_compose(const _Operation1& __x, const _Operation2& __y,
const _Operation3& __z)
: _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
typename _Operation1::result_type
operator()(const typename _Operation2::argument_type& __x) const {
return _M_fn1(_M_fn2(__x), _M_fn3(__x));
}
函数指针（ptr_mem）
这种配接器使我们能够将一般函数当作仿函数使用。
如果不使用这里的函数指针适配器先作一番包装，则一般函数无配接能力，无法和前面介绍的其他配接器接轨。
template <class _Arg, class _Result>
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
{
return pointer_to_unary_function<_Arg, _Result>(__x);
}
template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
_Result (*_M_ptr)(_Arg);
public:
pointer_to_unary_function() {}
explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
_Result operator()(_Arg __x) const { return _M_ptr(__x); }
};
成员函数指针适配器（mem_fun,mem_fun_ref）
这类适配器可将成员函数作为仿函数来使用。
当容器中存放的是类的指针或者引用类型时，利用泛型算法对容器中元素进行处理时，便可使用成员函数指针适配器动态调用类中定义的虚函数，从而实现多态。
成员函数指针适配器按照参数个数，通过引用还是指针调用，以及是否为静态成员函数，可以分为8种：
| 函数名称 | 特征 |
|---|---|
| mem_fun(S (T::*f)()) | 无参数；pointer；non-const |
| mem_fun1(S (T::*f)(A)) | 有参数；pointer；non-const |
| mem_fun(S (T::*f)() const) | 无参数；pointer；const |
| mem_fun1(S (T::*f)(A) const) | 有参数；pointer；const |
| mem_fun_ref(S (T::*f)()) | 无参数；reference；non-const |
| mem_fun1_ref(S (T::*f)(A)) | 有参数；reference；non-const |
| mem_fun_ref(S (T::*f)() const) | 无参数；reference；const |
| mem_fun1_ref(S (T::*f)(A) const) | 有参数；reference；const |