C++如何写adaptable仿函数

关于仿函数很多博客上都有，形式很简单，用途也很多。

一句话总结：重载了()运算符的类可以称之为仿函数functor

现在写一个“比较”

class MyLess{
public:
bool operator()(int a, int b){
return a < b;
}
};

大多数人会这样写，其实这样写没有错，而且基本所有算法都可以通过

比如：

class MyLess{
public:
bool operator()(int a, int b){
return a < b;
}
};
class Less10{
public:
bool operator()(int a){
return a < 10 ? true : false;
}
};
int main() {
vector<int> v{1, 40, 5, 60, 5, 6};
cout<<count_if(v.begin(), v.end(), Less10())<<endl;
sort(v.begin(), v.end(), MyLess());
for(auto i : v)
cout<<i<<" ";
cout<<endl;
}

上面两个仿函数MyLess、Less10。两个算法count_if、sort。

这样的仿函数基本上可以用stl中所有的算法。

看看STL中less怎么写的吧

template <class T>
struct less : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x < y; }
};

除了模板，还有就是less继承了个binary_function，这个是什么鬼？

为什么要继承它？继承它有啥用？

看一个例子：

class MyLess{
public:
bool operator()(int a, int b){
return a < b;
}
};
int main() {
vector<int> v{1, 40, 5, 60, 5, 6};
cout<<count_if(v.begin(), v.end(), bind2nd(less<int>(), 50))<<endl;
}

bind2nd这个叫绑定器，可以绑定一个仿函数的第二个参数。

为啥要使用绑定器？看看第段代码，有没有发现我统计数组中小于10的元素个数太单一了？一点都没有可扩展性，当我们要小于50的时候又得再写一个仿函数，太累了。所以绑定器产生了，现在C++11的绑定都是用bind这个函数（这个函数太厉害了，比bind1nd，bind2nd强大的多，有机会可以去了解下）

回到正题，如果我们把less()换成我们自己写的仿函数，编译就有问题，为啥呢？抛开模板，就是没有继承那个什么鬼了。

看看那个鬼张啥样吧

template <class Arg1, class Arg2, class Result>
struct binary_function {
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};

啥？一个成员都木有啊。

其实看STL最大的收获是懂得了typedef的使用，别看简单的一个typedef，几乎在stl中无处不在，绑定器，适配器，萃取器等等，都和typedef密不可分，但是我们正真写程序用typedef的又有几个。

回到正题，我们在看看bind2nd

template <class Operation, class T>
inline binder2nd<Operation> bind2nd(const Operation& op, const T& x) {
typedef typename Operation::second_argument_type arg2_type;
return binder2nd<Operation>(op, arg2_type(x));
}

原来bind2nd要用typedef得到第二参数的类型啊，有啥用？为了检查第二参数是否类型正确，如果转换不了那就直接出错

so，结果就出来了，为啥要继承那个鬼。

再继续看看binder2nd吧

template <class Operation>
class binder2nd
: public unary_function<typename Operation::first_argument_type,
typename Operation::result_type> {
protected:
Operation op;
typename Operation::second_argument_type value;
public:
binder2nd(const Operation& x,
const typename Operation::second_argument_type& y)
: op(x), value(y) {}
result_type operator()(const argument_type& x) const {
return op(x, value);
}
};

这里也需要知道参数类型和返回类型，而且binder2nd本身也是一个仿函数，而且继承了unary_function类

template <class Arg, class Result>
struct unary_function {
typedef Arg argument_type;
typedef Result result_type;
};

到此为止我们可以总结了

仿函数如果要融入STL那么需要继承一个类

一个参数用unary_function

两个参数用binary_function

注意：为啥binary_function有两个参数还是继承unary_function呢？

因为binary_function需要别人推导的只有第一参数而已，第二参数类型已经确定，在本类中已经typedef了