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)," "));