函数适配器(function adapter):通过不同函数适配器的绑定,组合和修饰能力,可以实现强大的功能,配合STL泛型算法完成复杂功能。
绑定(bind)
template
class binder1st
: public unary_function {
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
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
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{
return unary_negate<_Predicate>(__pred);
}
template
class unary_negate
: public unary_function {
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
inline unary_compose<_Operation1,_Operation2>
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}
template
class unary_compose
: public unary_function
{
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
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
{
return pointer_to_unary_function<_Arg, _Result>(__x);
}
template
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 |