【C++ 十九】STL-函数对象（仿函数）、一元谓词、二元谓词、算术仿函数、关系仿函数、逻辑仿函数
STL-函数对象（仿函数）、谓词、内建函数对象
文章目录
前言
本文包含函数对象概念、函数对象使用、谓词概念、 一元谓词、 二元谓词、内建函数对象意义、算术仿函数（plus()、minus()、multiplies()、divides()、modulus()、negate()）、关系仿函数（equal_to()、not_equal_to()、greater()、greater_equal()、less()、less_equal()）、逻辑仿函数（logical_and()、logical_or()、logical_not()）。
1 函数对象
1.1 函数对象概念
概念：
（1）、重载 函数调用操作符 的类，其对象常称为 函数对象
（2）、函数对象 使用重载的()时，行为类似函数调用，也叫 仿函数
本质： 函数对象(仿函数)是一个 类，不是一个函数
1.2 函数对象使用
特点：
（1）、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
（2）、函数对象超出普通函数的概念，函数对象可以有自己的状态
（3）、函数对象可以作为参数传递
// 函数对象（仿函数）
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
class fun_Add {
public:
int operator()(int a, int b) { // 重载函数调用操作符()，返回两数之和
return a + b;
}
};
void test01() {
fun_Add fun_add; // 通过fun_Add类，创建一个fun_add函数对象
cout << "两数之和为：" << fun_add(10, 20) << endl;
}
// 2、函数对象可以有自己的状态；函数对象超出普通函数的概念
class fun_Print {
public:
fun_Print() { // 无参构造函数，初始化count为0
this->count = 0;
}
void operator()(string str) { // 重载函数调用操作符()，打印传入的参数
cout << str << endl;
count++; // 统计使用次数，每调用一次加1
}
int count; // 记录内部自己的状态；如果是普通函数，需要声明全局变量或静态变量，来记录调用次数（普通函数不是类，没有成员属性）
};
void test02() {
fun_Print fun_print; // 通过fun_Print类，创建一个fun_print函数对象
fun_print("Learning C++");
fun_print("学习使用我快乐！");
fun_print("123");
cout << "fun_print调用次数为：" << fun_print.count << endl;
}
// 3、函数对象可以作为参数传递
void do_Print(fun_Print& fp, string str) { // 函数体，打印字符串
fp(str); // fun_Print函数fun_print对象作为一个参数，向一个do_Print函数中传递，传递&mp，传递之后，利用自身重载的函数调用操作符()，调用函数
}
void test03() {
fun_Print fun_print; // 通过fun_Print类，创建一个print函数对象
do_Print(fun_print, "Hello C++"); // 利用函数对象fun_print，以及传入打印的参数"Hello C++"，间接调用仿函数fun_Print
}
int main() {
test01();
cout << endl;
test02();
cout << endl;
test03();
cout << endl;
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2 谓词
2.1 谓词概念
概念：
（1）、返回 bool 类型的仿函数称为 谓词
（2）、如果 operator() 接受一个参数，那么叫做一元谓词
（3）、如果 operator() 接受两个参数，那么叫做二元谓词
2.2 一元谓词
// 仿函数：返回值类型是bool数据类型，称为谓词
// 一元谓词
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <vector>
#include <algorithm>
// 结构体中定义一元谓词，用法和类的用法很想，struct中定义的函数和变量默认为public，但class中的则是默认为private
struct Greater_5 {
bool operator()(int i) { // 重载函数调用符()的类，且返回bool类型，接收一个参数的仿函数，为一元谓词
return i > 5;
}
};
void test() {
vector<int> v; // 创建单端数组容器v，使用时必须包含头文件vector
for (int i = 0; i < 10; i++) {
v.push_back(i); // 向单端数组容器中插入十个数
}
// 查找容器中，有没有大于5的数字
// Greater_5()匿名函数对象；正常创建一个对象，需通过类Greater_5，创建一个对象，调用对象属性或方法；不想创建对象或给对象起名，可以使用匿名函数对象
// find_if()：按条件查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置；使用时需包含头文件algorithm
vector<int>::iterator it = find_if(v.begin(), v.end(), Greater_5()); // 返回值类型为迭代器
if (it == v.end()) { // 判断返回值是否是v的end()结束迭代器，如果是，则没找到；如果不是，则找到了，返回指定位置迭代器
cout << "没找到！" << endl;
}
else {
cout << "找到： " << *it << endl; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2.3 二元谓词
// 二元谓词
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <vector>
#include <algorithm>
class Fun_Compare {
public:
bool operator()(int a, int b) { // 重载函数调用符()的类，且返回bool类型，接收两个参数的仿函数，为二元谓词
return a > b; // 降序
}
};
void test() {
vector<int> v; // 创建单端数组容器v，使用时必须包含头文件vector
v.push_back(20); // 向单端数组容器中插入数据
v.push_back(60);
v.push_back(80);
v.push_back(30);
v.push_back(40);
// sort()：将区间内的元素进行排序，默认从小到大排序；使用时需包含头文件algorithm
sort(v.begin(), v.end());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) { // vector<int>::iterator 拿到vector<int>这种容器的迭代器类型；每个容器都有一个专属的迭代器类型
cout << *it << " "; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
cout << endl; // 换行
cout << "---------------------------------" << endl;
// sort()：区间内的元素按照用户指定的顺序Fun_Compare()排列
sort(v.begin(), v.end(), Fun_Compare()); // Fun_Compare()匿名函数对象；正常创建一个对象，需通过类Fun_Compare，创建一个对象，调用对象属性或方法；不想创建对象或给对象起名，可以使用匿名函数对象
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl; // 换行
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3 内建函数对象
3.1 内建函数对象意义
概念： STL 内建了一些函数对象
分类：
（1）、算术仿函数
（2）、关系仿函数
（3）、逻辑仿函数
用法：
（1）、这些仿函数所产生的对象，用法和一般函数完全相同；
（2）、使用内建函数对象，需要引入头文件 #include <functional>
3.2 算术仿函数
功能描述：
（1）、实现四则运算
（2）、其中 negate（取反仿函数）是一元运算，其他都是二元运算
仿函数原型：
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> 取反仿函数
// 內建函数对象：算术仿函数
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <functional> // 内建函数对象头文件
void test() {
int a = 20;
int b = 10;
// 1、plus；二元仿函数，加法
plus<int> p; // <int>模板参数可以写一个，默认认为传入的都是同种类型，不存在int和float等不同类型进行相加
cout << "a + b = " << p(a, b) << endl;
// 2、minus；二元仿函数，减法
minus<int> m; // <int>模板参数可以写一个，默认认为传入的都是同种类型，不存在int和float等不同类型进行相减
cout << "a - b = " << m(a, b) << endl;
// 3、multiplies；二元仿函数，乘法
multiplies<int> mul; // <int>模板参数可以写一个，默认认为传入的都是同种类型
cout << "a * b = " << mul(a, b) << endl;
// 4、divides；二元仿函数，除法
divides<int> d; // <int>模板参数可以写一个，默认认为传入的都是同种类型
cout << "10 / 10 = " << d(10, 20) << endl;
divides<int> d1;
cout << "20 / 10 = " << d1(20, 10) << endl;
divides<int> d2;
cout << "10 / 2.5 = " << d2(10, 2.5) << endl;
divides<double> d3;
cout << "44.88 / 22.55555 = " << d3(44.88, 22.5555) << endl;
// 5、modulus；二元仿函数，取模
modulus<int> mod; // <int>模板参数可以写一个，默认认为传入的都是同种类型
cout << "10 % 20 = " << mod(10, 20) << endl;
modulus<int> mod1;
cout << "20 % 10 = " << mod1(20, 10) << endl;
modulus<int> mod2;
cout << "-10 % 3 = " << mod2(-10, 3) << endl;
// 6、negate；二元仿函数，取反
negate<int> n; // <int>模板参数可以写一个，默认认为传入的都是同种类型
cout << "10 = " << n(10) << endl;
negate<int> n1;
cout << "-5 = " << n1(-5) << endl;
negate<double> n2;
cout << "-10.88 = " << n2(-10.88) << endl;
}
int main() {
test();
cout << endl;
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.3 关系仿函数
功能描述： 实现关系对比
仿函数原型：
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> 小于等于
// 关系仿函数：等于仿函数
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <functional> // 内建函数对象头文件
#include <vector>
#include <algorithm>
void test() {
// 初始化vector
vector<int> v1 = { 10,20,30,40,50,60 };
vector<int> v2 = { 10,20,30,100,50,60,0,-40 };
// 成对的声明指针
pair<vector<int>::iterator, vector<int>::iterator>pairs1;
// 1、使用mismatch（）函数搜索v1和v2之间的第一个不匹配；使用mismatch（）函数需包含algorithm头文件
pairs1 = mismatch(v1.begin(), v1.end(), v2.begin(), equal_to<int>());
// 打印不匹配的配对
cout << "第一个容器的第一个不匹配元素为： " << *pairs1.first << endl;
cout << "第二个容器的第一个不匹配元素为： " << *pairs1.second << endl;
cout << endl;
// 2、使用mismatch（）函数搜索v1和v2之间的第一个匹配项；使用mismatch（）函数需包含algorithm头文件
pairs1 = mismatch(v1.begin(), v1.end(), v2.begin(), not_equal_to<int>());
// 打印配对
cout << "第一个容器的第一个匹配元素为： " << *pairs1.first << endl;
cout << "第二个容器的第一个匹配元素为： " << *pairs1.second << endl;
cout << endl;
cout << "排序前：" << endl;
for (vector<int>::iterator it = v2.begin(); it != v2.end(); it++) { // 遍历单端数组
cout << *it << " "; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
cout << endl;
// 3、STL内建仿函数：大于仿函数；内建函数对象，可修改模板类型<int>
sort(v2.begin(), v2.end(), greater<int>());
cout << "排序后：" << endl;
for (vector<int>::iterator it = v2.begin(); it != v2.end(); it++) {
cout << *it << " ";
}
cout << endl;
cout << endl;
// 4、统计单端数组容器v中，大于等于0的元素个数
// count_if()：按条件统计元素出现次数
// bind2nd()：用于将一个二元函数转换成一元函数
int cx = count_if(v2.begin(), v2.end(), bind2nd(greater_equal<int>(), 0));
cout << "There are " << cx << " non-negative elements.\n"; // \n换行
cout << endl;
cout << "排序前：" << endl;
for (vector<int>::iterator it = v2.begin(); it != v2.end(); it++) { // 遍历单端数组
cout << *it << " "; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
cout << endl;
// 5、STL内建仿函数：小于仿函数；内建函数对象，可修改模板类型<int>
sort(v2.begin(), v2.end(), less<int>());
cout << "排序后：" << endl;
for (vector<int>::iterator it = v2.begin(); it != v2.end(); it++) {
cout << *it << " ";
}
cout << endl;
cout << endl;
// 6、统计单端数组容器v中，小于等于0的元素个数
// count_if()：按条件统计元素出现次数
// bind2nd()：用于将一个二元函数转换成一元函数
int cx1 = count_if(v2.begin(), v2.end(), bind2nd(less_equal<int>(), 0));
cout << "There are " << cx1 << " non-negative elements.\n"; // \n换行
cout << endl;
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.4 逻辑仿函数
功能描述： 实现逻辑运算
函数原型：
template<class T> bool logical_and<T> 逻辑与仿函数
template<class T> bool logical_or<T> 逻辑或仿函数
template<class T> bool logical_not<T> 逻辑非仿函数
// 逻辑仿函数：逻辑与仿函数
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <functional> // 内建函数对象头文件
#include <vector>
#include <algorithm>
void test() {
// 初始化vector
vector<bool> v = { true,true,false,false,true,false };
cout << "搬运前：" << endl;
for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) { // 遍历单端数组v
cout << *it << " "; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
cout << endl; // 1 1 0 0 1 0
// 将单端容器v搬运到单端容器v_Target中，并执行逻辑与运算
vector<bool> v_Target;
// resize()重置大小，扩大到和单端容器v一样的大小；目标容器必须开辟好大小，否则就是收缩不能搬运，会报错
v_Target.resize(v.size());
// 1、transform()搬运算法；第一个参数：源容器的begin()迭代器；第二个参数：源容器的end()迭代器；第三个参数：目标容器的起始迭代器；第四个参数：仿函数
transform(v.begin(), v.end(), v_Target.begin(), bind2nd(logical_and<bool>(), true)); // bind2nd(logical_and<bool>(), true)：与true进行运算
cout << "搬运后：" << endl;
for (vector<bool>::iterator it = v_Target.begin(); it != v_Target.end(); it++) {
cout << *it << " ";
}
cout << endl; // 1 1 0 0 1 0
cout << endl;
cout << "搬运前：" << endl;
for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) { // 遍历单端数组v
cout << *it << " "; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
cout << endl; // 1 1 0 0 1 0
// 2、transform()搬运算法；第一个参数：源容器的begin()迭代器；第二个参数：源容器的end()迭代器；第三个参数：目标容器的起始迭代器；第四个参数：仿函数
transform(v.begin(), v.end(), v_Target.begin(), bind2nd(logical_or<bool>(), true)); // bind2nd(logical_and<bool>(), true)：与true进行运算
cout << "搬运后：" << endl;
for (vector<bool>::iterator it = v_Target.begin(); it != v_Target.end(); it++) {
cout << *it << " ";
}
cout << endl; // 1 1 1 1 1 1
cout << endl;
cout << "搬运前：" << endl;
for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) { // 遍历单端数组v
cout << *it << " "; // it返回的是迭代器，迭代器本质是一个指针，使用*解引用
}
cout << endl; // 1 1 0 0 1 0
// 3、transform()搬运算法；第一个参数：源容器的begin()迭代器；第二个参数：源容器的end()迭代器；第三个参数：目标容器的起始迭代器；第四个参数：仿函数
transform(v.begin(), v.end(), v_Target.begin(), logical_not<bool>());
cout << "搬运后：" << endl;
for (vector<bool>::iterator it = v_Target.begin(); it != v_Target.end(); it++) {
cout << *it << " ";
}
cout << endl; // 0 0 1 1 0 1
}
int main() {
test();
cout << endl;
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
总结
（1）、仿函数写法非常灵活，可以作为参数进行传递；
（2）、参数只有一个的谓词，称为一元谓词；
（3）、参数只有两个的谓词，称为二元谓词；
（4）、使用内建函数对象时，需要引入头文件 #include <functional>；
（5）、关系仿函数中最常用的就是 greater<> 大于；
（6）、逻辑仿函数实际应用较少，了解即可。