STL与泛型编程<十五>：预定义的仿函数和仿函数适配器
如下图，STL中预定于的这些仿函数
使用请先头文件#include
由上图可以看出，总的来说可以分成一元仿函数（只有一个参数）和二元仿函数（两个参数）；又可以分为：算术类，相对关系类，逻辑运算类。
函数适配器(Function Adapters)调用原理分析
binder1st and bind1st
目的在于将无法匹配的仿函数适配成可以匹配的型别，类似于生活中的插座。先看一个例子1:给定一个vector，其元素为【0，0，0，10，0，2】,如何通过not_equal_to匹配到第一个非零元素呢？也许你会这么解
vector<int>::iterator pos = find_if(col.begin(),col.end(),not_equal_to<int>(0));但是却行不通，原因有两个
1. not_equal_to构造函数不接受参数“0”
2. not_equal_to的operator()不接受一个参数，需要两个参数!
其C++98声明如下所示
template <class T>
struct not_equal_to : binary_function <T,T,bool>
{
bool operator() (const T& x, const T& y) const
{return x!=y;}
};其C++11声明如下：
template <class T>
struct not_equal_to
{
bool operator() (const T& x, const T& y) const {return x!=y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
解决办法是通过binder1st套接not_equal_to,可以看出仿函数的作用就是：如果想要用的仿函数，由于参数方面不符合要求，那么可以通过适配器来进行适配。
先来看下binder1st型别的部分定义
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); }
};
/* 可以看出 1. binder1st是个template class型别，共有两个成员变量：op和value，其中根据命名含义可以得知op是操作(函数)，而value是个op操作中所需的第一个参数； 2.binder1st共有两个成员函数，一个构造函数，一个重载了operator()运算符； 3.其中构造函数需要两个参数来初始化其成员，显然一个是op，一个是value； 4.其operator()操作返回op(value,x)，显然value就是op操作的第一个参数，而还需要传入第二个参数x。 5.由于其重载了operator()操作，可以说binder1st也是个仿函数 */再看下not_equal_to的源代码(C++ 11)
template <class T>
struct not_equal_to
{
bool operator() (const T& x, const T& y) const {return x!=y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
接下来看使用过程
typename not_equal_to<int>::first_argument_type nonZero(0);
not_equal_to<int> f;
vector<int> pos;
pos = find_if(col.begin(),col.end(),
binder1st<not_equal_to<int> >(f,nonZero));
/* 1.显然是把binder1st当作仿函数使用； 2.由上面的定义可知，binder1st是个template型别，需要op（操作）来初始化； 3.调用其operator()操作，由上面其binder1st源代码看出f即是op操作，nonZero即是Operation::first_argument_type value; 4.因此就是调用op(value,x)也就是f(value,x),也就是not_equal_to<int>(value,x); 5.显然value是左值，也就是nonZero（就是0啦），那么ｘ（右值是谁），可以猜到，正式find_if()中迭代器范围中的每个值。 6.因此find_if(...)调用就可以看成如下行为了: for (pos=beg; pos!=end; ++pos) if (not_equal_to(value,*pos)) break; */然后看下find_if的源代码
template<class InputIterator, class UnaryPredicate>
InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
while (first!=last) {
if (pred(*first)) return first;
++first;
}
return last;
}
/* 可以知道其实调用pred的operator()操作 */实际调用的时候，其实更简单,用bind1st(template function)替代binder1st(template class)
vector<int>::iterator pos;
pos = find_if(vol.begin(),col.end(),bind1st(not_equal_to<int>(),0);//因此这个0就是not_equal_to()操作中的左值，而容器中的元素就是其右值因此这个0就是not_equal_to()操作中的左值，而容器中的元素就是其右值
bind1st封装了binder1st的复杂性
template <class Operation, class T>
binder1st<Operation> bind1st (const Operation& op, const T& x)
{
return binder1st<Operation>(op, typename Operation::first_argument_type(x));
}
/* 可知需要带入两个参数：第一个参数是仿函数，第二个是个值（左值） */binder2nd and bind2st
其实bind2nd和bind1st也一样，区别在于bind2nd中的参数value是其参数op的右值，而bind1st是左值。下面看代码就清楚了
template <class Operation, class T>
binder1st<Operation> bind1st (const Operation& op, const T& x)
{
return binder1st<Operation>(op, typename Operation::first_argument_type(x));
}
/* 可以看出x是op操作的第一个参数（左值） */template <class Operation, class T>
binder1st<Operation> bind1st (const Operation& op, const T& x)
{
return binder1st<Operation>(op, typename Operation::first_argument_type(x));
}
/* 可以看出x是op操作的第二个参数（左值） */下面看一个使用两个适配器对比的例子
vector<int>::iterator pos;
pos = find_if(col.begin(),col.end(),bind1st(less<int>(),0)); //0<容器的元素
pos = find_if(col.begin(),col.end(),bind2nd(greater<int>(),0)); //容器的元素>0
/* 这两个表达式是等效的 */适配器
所谓的函数适配器就是将仿函数和另一个仿函数（或某个值，或一般函数）结合起来组成一个仿函数，其声明也在#include 中
如以下
find_if(col.begin(),col.end(),bind2nd(greater<int>(),42)) /* 解释：greater<int>() 其中greater是个template型别，因此需要指定类型,如int，则写成greater<int>,然后再产生一个临时对象则可以写成greater<int>()，且会调用其operator()成员函数（而这个是由于算法决定的） */其中bind2nd(greater(),42)是一个组合仿函数，检查某个值是否大于42，实际上是bind2nd是将一个二元仿函数(greater<>)转换为一元仿函数，其中42作为二元仿函数greater<>的第二个参数。因此上诉程序以42来作为参数来调用greater<>。
如下图是一些预定义的函数适配器及其效果
函数适配器也是仿函数，因此可以结合仿函数以形成更为强大（更复杂）的表达式，如下
pos = find_if(col.begin(),col.end(),not1(bind2nd(modulus<int>(),2)));
/*
bind2nd(modulus<int>(),2)表示对2取模，其中奇数会返回1（相当于true），偶数会返回0(false)，因此是一个寻找奇数的,而not1又使之反过来了
*/针对成员函数而设计的函数适配器
为什么需要成员函数的适配器？
对于函数及对象obj,在obj上调用f的形式有以下三种
（1）f(obj);//f是全局函数（非obj的成员函数）
（2）obj.f();//f是成员函数，obj非指针
（3）obj->f();//f是成员函数，obj指针
但是看下STL中算法的实现过程就可知道了，比如for_each
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function fn) { while (first!=last) {
fn (*first);
++first;
}
return fn; // or, since C++11: return move(fn); }如果这样情况下就只能使用(1)的形式了。
而我们是通过 mem_fun（容器中的元素是指针就使用这个）/mem_fun_ref（否则使用这个）来实现调用对象的成员函数的
就是透过这些适配器你可以对区间的每个元素都调用其成员函数，如下
例子如下
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <functional>
using namespace std;
class Person
{
private:
string _name;
public:
Person(string name)
: _name(name) {}
void print() const
{
cout << _name << endl;
}
void print_with_prefix(const string& prefix) const
{
cout << prefix << _name << endl;
}
};
void foo(const vector<Person>& col)
{
for_each(col.begin(),col.end(),mem_fun_ref(&Person::print)); //刚开始错写为&Person::print()，不需要加()
//for_each(col.begin(),col.end(),bind2nd(mem_fun_ref(&Person::print_with_prefix("person: ")))); 开始的错误写法
string str = "person : ";
for_each(col.begin(),col.end(),bind2nd(mem_fun_ref(&Person::print_with_prefix),str));
//但是这样就会出现乱码？为什么
}
int main(void)
{
vector<Person> col;
Person p1("david");
Person p2("summer");
col.push_back(p1);
col.push_back(p2);
foo(col);
return 0;
} 若将类型换为vector
让自己定义的仿函数可以使用适配器
你可以编写自己的仿函数（如前面的例子），但如果要希望它们能够和函数适配器搭配使用的话，就必须满足以下：提供一些型别成员来反映其参数和返回值的型别。C++标准程序库提供了以下的一些结构
template<typename Arg, typename Result>
struct unary_function
{
typedef Arg argument_type;
typedef Result result_type;
}
template<typename Arg1, typename Arg2, typename Result>
struct binary_function
{
typedef struct first_argument_type;
typedef struct second_argument_type;
typedef struct result_type;
}见下例子
#include <iostream>
#include <functional>
#include <cmath>
#include <algorithm>
#include <iterator>
#include <vector>
using namespace std;
template<typename T1, typename T2>
class fopow : public binary_function<T1, T2, T1>
{
public:
T1 operator() (T1 base, T2 exp) const
{
return pow(base,exp);
}
};
int main(void)
{
vector<int> col;
for (int i=1; i<=9; ++i)
col.push_back(i);
transform(col.begin(),col.end(),ostream_iterator<int>(cout," "),bind1st(fopow<float,int>(),3));
cout << endl;
transform(col.begin(),col.end(),ostream_iterator<int>(cout," "),bind2nd(fopow<float,int>(),3));
return 0;
}
/* 输出：3 9 27 81 243 729 2187 6561 19683 1 8 27 64 125 216 343 512 729 */针对一般函数（非成员函数）使用的函数适配器
可以使用函数适配器ptr_fun，规则如下
ptr_fun(op);
/* 可翻译如下： (1)op(param); (2)op(param1,param2); */看一个例子，一个参数的全局函数
bool check(int elem);
pos = find_if(col.begin(),col.end(),not1(ptr_fun(check)));两个参数的全局函数
pos = find_if(col.begin(),col.end(),bind2nd(ptr_fun(strcmp)," "));