内建函数对象（STL）

引言

函数对象是重载函数调用操作符的类，函数对象使用重载的()时，因为类似函数调用，也叫仿函数
所以仿函数（函数对象）就是一个类

我们可以自己建立函数对象，这里就不具体说了；STL中同样给我们提供了一些内建的函数对象，可以直接使用；
分为以下三种：

算术仿函数
关系仿函数
逻辑仿函数

这些仿函数的用法和一般的函数用法差不多相同，但是使用需要头文件#include<functional>

算术仿函数

几种常见的算术仿函数：

template<class T> T plus<T>          //加法仿函数
template<class T> T minus<T>         //减法仿函数
template<class T> T multiplies<T>    //乘法仿函数
template<class T> T divides<T>       //除法仿函数
template<class T> T modulus<T>       //取模仿函数
template<class T> T negate<T>        //取反仿函数

这里面只有negate是一元运算，其他都是二元运算，所以下面的示例代码我们就举 negate 和 multiplies 一个一元一个二元，二元用法都一样；
代码如下：

#include<iostream>
#include<functional>int main() {//取反仿函数 std::negate<int> n;std::cout << n(10) << std::endl;//乘法仿函数std::multiplies<int> m;std::cout << m(10, 10) << std::endl;return 0;
}

关系仿函数

关系仿函数的几种常见类型：

template<class T> bool equal_to<T>         //等于
template<class T> bool not_equal_to<T>     //不等于
template<class T> bool greater<T>          //大于
template<class T> bool greater_equal<T>    //大于等于
template<class T> bool less<T>             //小于
template<class T> bool less_equal<T>       //小于等于

这里面用的最多的其实是 greater，下面例子也是它的，其余的了解就行；
（这里记录 greater 也是为了 sort 从大到小排列节省步骤）
（一定要记住sort(vec.begin(), vec.end(), greater<int>());这个形式）
代码如下：

#include<iostream>
#include<functional>
#include<algorithm>
using namespace std;//自己创建的仿函数
class MyCompare {public:bool operator() (int a, int b) {return a > b;}
};int main() {vector<int> vec;vec.push_back(20);vec.push_back(40);vec.push_back(10);vec.push_back(30);vec.push_back(90);//正常sort排序是从小到大sort(vec.begin(), vec.end());for (int i : vec) cout << i << ' '; cout << endl;//让sort从大到小排序方法：// 1，自己写个仿函数 // sort(vec.begin(), vec.end(), MyCompare());// 2，用STL的内建函数对象大于greater */ sort(vec.begin(), vec.end(), greater<int>());for (int i : vec) cout << i << ' '; cout << endl;return 0;
}

为了加深对sort理解，可以看一下sort实现的部分源码：

可以看到sort分别被定义了两种形式，第一种就是有三个参数，
这里我们主要看第二种两个参数，sort 默认从小到大排序的原理就在这里，
可以看到黄色部分是一个less<>()，这个不就是关系仿函数中的小于仿函数嘛；
所以sort才会默认从小到大
所以就能很好理解关系仿函数和sort了；

逻辑仿函数

逻辑仿函数没有什么说的，用的也不多，就罗列以下，以后要是用到了再补充；

template<class T> bool logical_and<T>              //逻辑与
template<class T> bool logical_or<T>               //逻辑或
template<class T> bool logical_not<T>              //逻辑非

总结

这里还是着重强调下算术仿函数和关系仿函数，尤其要记住关系仿函数中的greater<>()，同样要根深一层的理解sort；