🎩 欢迎来到技术探索的奇幻世界👨💻
📜 个人主页：@一伦明悦-CSDN博客
✍🏻 作者简介： C++软件开发、Python机器学习爱好者
🗣️ 互动与支持：💬评论 👍🏻点赞 📂收藏 👀关注+
如果文章有所帮助，欢迎留下您宝贵的评论，
点赞加收藏支持我，点击关注，一起进步！
前言
在C++中，STL（Standard Template Library）中的函数对象（function object）、谓词（predicate）和仿函数（functor）是关键概念，用于实现通用算法的灵活性和可定制性。
正文
01-函数对象
函数对象概念
概念： 重载函数调用操作符的类，其对象常称为函数对象 函数对象使用重载的()时，行为类似函数调用，也叫仿函数
本质： 函数对象(仿函数)是一个类，不是一个函数
函数对象使用
特点： 函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
函数对象超出普通函数的概念
函数对象可以有自己的状态
函数对象可以作为参数传递
下面给出具体代码：代码演示了C++中函数对象的基本用法及其特性：
-
MyAdd 类：
MyAdd是一个函数对象类，重载了operator()，使其能够像函数一样被调用。operator()接受两个int类型的参数，并返回它们的和。- 在
test01函数中，展示了如何创建MyAdd的实例myadd并调用它来执行加法操作。
-
MyPrint 类：
MyPrint类也是一个函数对象类，同样重载了operator()。operator()接受一个string类型的参数test，并将其输出到标准输出流。MyPrint类内部还定义了一个count成员变量，用于统计operator()被调用的次数。- 在
test02函数中，展示了如何创建MyPrint的实例myPrint，并重复调用它来打印消息，并最后输出调用次数。
- test03 函数：
test03函数展示了如何将函数对象作为参数传递给另一个函数。- 在
main函数中调用了test03，它首先创建了MyPrint的实例myPrint。 - 然后调用
doPrint函数，并将myPrint对象和一个string参数"Hello C++"传递给它。 doPrint函数内部调用了传入的MyPrint对象的operator()，输出了"Hello C++"，并递增了count。
函数对象的优势在于它们可以像普通函数一样调用，并且可以保持自己的状态。这使得它们比简单的函数指针或Lambda表达式更为灵活，特别适合于需要重复调用和状态管理的场景，例如在算法中作为自定义操作的手段。
#include<iostream>
using namespace std;
#include<string>
class MyAdd
{
public:
int operator()(int v1, int v2)
{
return v1 + v2;
}
};
void test01()
{
// 1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
MyAdd myadd;
cout << myadd(10, 10) << endl;
}
//2、函数对象可以有自己的状态
class MyPrint
{
public:
MyPrint()
{
count = 0;
}
void operator()(string test)
{
cout<<test<<endl;
count++; //统计使用次数
}
int count; //内部自己的状态
};
void test02()
{
MyPrint myPrint;
myPrint("hello world");
myPrint("hello world");
myPrint("hello world");
cout << "myPrint调用次数为： " << myPrint.count << endl;
}
//3、函数对象可以作为参数传递
void doPrint(MyPrint &mp, string test)
{
mp(test);
}
void test03()
{
MyPrint myPrint;
doPrint(myPrint, "Hello C++");
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}02-一元谓词
概念： 返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词
代码如下：这段代码演示了如何使用函数对象（谓词）作为算法 std::find_if 的参数来查找符合特定条件的元素。
-
结构体
GreaterFive的定义：GreaterFive是一个结构体，它实现了函数调用操作符operator()。operator()接受一个int类型的参数val，并返回一个布尔值，表示该值是否大于5。
struct GreaterFive { bool operator()(int val) { return val > 5; } };这里的
GreaterFive是一个一元谓词，因为它只接受一个参数。 -
函数
test01()：test01()函数创建了一个vector<int>容器v，并填充了0到9的整数。- 使用了 STL 中的
std::find_if算法来查找第一个满足GreaterFive()函数对象条件的元素。
void test01() { vector<int> v; for (int i = 0; i < 10; i++) { v.push_back(i); } vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive()); if (it == v.end()) { cout << "没找到!" << endl; } else { cout << "找到:" << *it << endl; } }find_if接受三个参数：容器的起始迭代器v.begin()、容器的结束迭代器v.end()，以及一个谓词GreaterFive()。find_if会从容器的开始位置到结束位置遍历每个元素，并调用GreaterFive()的operator()来判断是否大于5。- 如果找到符合条件的元素，
find_if返回该元素的迭代器；如果遍历结束没有找到，则返回v.end()。
-
main()函数：main()函数调用了test01()来执行测试。
test01()中的find_if首先会传入GreaterFive()谓词对象，并对v中的每个元素调用GreaterFive的operator()。- 如果找到第一个大于5的元素，将输出其值；如果未找到符合条件的元素，输出 “没找到!”。
这段代码展示了函数对象作为谓词在STL算法中的应用。谓词允许我们灵活地定义条件，用于算法中的判断和筛选操作，使得算法更加通用和可复用。
#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
//1.一元谓词
struct GreaterFive {
bool operator()(int val) {
return val > 5;
}
};
void test01() {
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it == v.end()) {
cout << "没找到!" << endl;
}
else {
cout << "找到:" << *it << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}03-二元谓词
概念： 返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词
这段代码展示了在STL中如何使用二元谓词（函数对象）来改变排序算法的比较方式，并进行从大到小的排序操作。
- 类
MyCompare的定义：MyCompare是一个类，重载了函数调用操作符operator()，接受两个int类型参数，并返回一个布尔值。operator()实现了按照第一个参数大于第二个参数的逻辑进行比较。
class MyCompare
{
public:
bool operator()(int num1, int num2)
{
return num1 > num2;
}
};
-
函数
test01()的内容：test01()函数创建了一个vector<int>类型的容器v，并向其中添加了一些整数。- 首先通过
sort(v.begin(), v.end())默认排序从小到大对容器v进行排序，并输出排序结果。 - 然后通过
sort(v.begin(), v.end(), MyCompare())使用自定义的二元谓词MyCompare改变排序方式为从大到小，并输出结果。
-
执行流程总结：
- 第一次调用
sort默认按从小到大排序。 - 第二次使用
sort时，将MyCompare()作为参数传入，改变排序规则为从大到小。
- 第一次调用
-
main()函数：main()函数调用test01()来执行测试。
- 第一次排序输出结果应该是: 10 20 30 40 50
- 第二次使用
MyCompare作为谓词进行排序，输出结果应该是: 50 40 30 20 10
这段代码展示了如何使用二元谓词（函数对象）来自定义比较操作，以便在STL算法中改变默认的排序方式。通过传入不同的比较函数对象，可以根据实际需求灵活地定制排序规则，使得STL算法在处理数据时更加灵活和通用。
#include <vector>
#include <algorithm>
//二元谓词
class MyCompare
{
public:
bool operator()(int num1, int num2)
{
return num1 > num2;
}
};
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(40);
v.push_back(20);
v.push_back(30);
v.push_back(50);
//默认从小到大
sort(v.begin(), v.end());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
cout << "----------------------------" << endl;
//使用函数对象改变算法策略，排序从大到小
sort(v.begin(), v.end(), MyCompare());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}04-算术仿函数
概念： STL内建了一些函数对象
分类: 算术仿函数
仿函数原型： template T plus //加法仿函数 template T minus //减法仿函数 template T multiplies //乘法仿函数 template T divides //除法仿函数 template T modulus //取模仿函数 template T negate //取反仿函数
这段代码展示了如何使用C++标准库中提供的内建函数对象（仿函数），包括 negate 和 plus。
negate仿函数：negate是一元仿函数，它接受一个参数并返回该参数的相反数。- 在
test01函数中，创建了一个negate<int>对象n。 n(50)调用negate的operator()，返回-50。
void test01()
{
negate<int> n;
cout << n(50) << endl;
}
plus仿函数：plus二元仿函数，用于执行加法操作。- 在
test02函数中，创建了一个plus<int>对象p。 p(10, 20)调用plus的operator()，返回10 + 20的结果，即30。
void test02()
{
plus<int> p;
cout << p(10, 20) << endl;
}
main函数依次调用了test01和test02函数来测试这些内建函数对象。test01函数输出-50。test02函数输出30。
这段代码展示了如何使用C++标准库中提供的内建函数对象，如 negate 和 plus。这些仿函数可以用来执行一些基本的算术操作，例如取反和加法，并且可以作为算法的参数来使用，从而提供了灵活性和通用性。
#include<iostream>
using namespace std;
#include <functional> //内建函数对象头文件
// 内建函数对象，也就是仿函数，算术仿函数
// negate 一元仿函数 取反使用
void test01()
{
negate<int>n;
cout << n(50) << endl;
}
// plus 二元仿函数，加法
void test02()
{
plus<int>p; // 这里写一个数据类型就行，因为默认另外一个和这个同类型
cout << p(10, 20) << endl;
}
int main()
{
test01();
system("pause");
return 0;
}05-关系仿函数
关系仿函数（Relational Function Objects）是C++标准库中的一类仿函数，用于比较两个值的大小关系。它们通常用于STL算法中的排序、查找等操作，以定义元素之间的顺序。
在C++中，常见的关系仿函数包括：
less<T>：对于类型T的值，返回true如果第一个参数严格小于第二个参数。less_equal<T>：对于类型T的值，返回true如果第一个参数小于或等于第二个参数。greater<T>：对于类型T的值，返回true如果第一个参数严格大于第二个参数。greater_equal<T>：对于类型T的值，返回true如果第一个参数大于或等于第二个参数。equal_to<T>：对于类型T的值，返回true如果两个参数相等。not_equal_to<T>：对于类型T的值，返回true如果两个参数不相等。这些仿函数都是二元的，即它们接受两个参数并返回一个布尔值，根据比较结果决定大小关系。它们可以直接在STL算法中使用，例如在
sort函数中指定排序的方式，或在find_if函数中指定查找的条件。通过使用这些关系仿函数，程序员可以根据具体的需求灵活地定义和改变元素之间的比较规则，从而使得STL算法更加通用和适用于不同的场景。
这段代码展示了如何使用C++标准库中的内置仿函数 greater 来改变默认的排序顺序，从而实现从大到小的排序操作。
-
包含的头文件：
#include <vector> #include <deque> #include <algorithm> #include <functional>vector和algorithm是标准库中用于操作容器和算法的头文件。functional包含了内置的函数对象（仿函数）。
-
test01()函数：- 创建了一个
vector<int>容器v，并向其中添加了一些整数。 - 使用循环输出容器中的元素。
void test01() { vector<int> v; v.push_back(10); v.push_back(20); v.push_back(40); v.push_back(30); for (vector<int>::iterator it = v.begin(); it != v.end(); it++) { cout << *it << " "; } cout << endl; } - 创建了一个
-
排序操作：
- 使用
sort(v.begin(), v.end(), greater<int>())对容器v进行排序，其中greater<int>()是一个内置的仿函数，用于比较两个元素并返回较大的那个。 - 这样排序会使容器中的元素按照从大到小的顺序排列。
sort(v.begin(), v.end(), greater<int>()); - 使用
-
输出排序后的结果：
- 再次使用循环输出排序后的容器元素，验证排序结果是否正确。
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) { cout << *it << " "; } cout << endl;
main()函数调用了test01()来执行测试。- 初始时，输出未排序的容器元素：10 20 40 30
- 经过使用
sort和greater<int>()进行排序后，输出排序后的结果：40 30 20 10
这段代码展示了如何使用C++标准库中的内置函数对象 greater，它是一个二元仿函数，用于在STL算法中实现从大到小的排序。通过这种方式，可以轻松地改变默认的排序顺序，使得STL的算法更加灵活和通用。
#include <iostream>
using namespace std;
#include <vector>
#include <deque>
#include <algorithm>
#include <functional>
void test01()
{
vector<int>v;
v.push_back(10);
v.push_back(20);
v.push_back(40);
v.push_back(30);
for (vector<int>::iterator it = v.begin(); it != v.end();it++)
{
cout << *it << " ";
}
cout << endl;
// 除了使用自定义仿函数排序外，还可以使用内置仿函数 greater从大到小
sort(v.begin(), v.end(), greater<int>());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}总结
函数对象（Function Object）：
- 函数对象是一种重载了函数调用操作符
operator()的类对象，它允许对象像函数一样被调用。- 在STL中，很多算法（比如排序、查找等）可以接受函数对象作为参数，以便根据自定义的逻辑进行操作。
- 函数对象可以存储状态，因此它比简单的函数指针更灵活，可以实现更复杂的行为。
struct MyFunctionObject { bool operator()(int a, int b) const { return a < b; } };谓词（Predicate）：
- 谓词是一种特殊的函数对象，它返回一个布尔值，用于描述一个对象是否满足某个条件。
- 在STL中，谓词通常用于算法中的判断条件，例如在
std::find_if中指定一个条件来查找满足条件的元素。- 谓词可以是函数指针、函数对象或者Lambda表达式。
bool IsOdd(int num) { return num % 2 != 0; }仿函数（Functor）：
- 仿函数是一个类对象，重载了
operator()，使得它可以像函数一样被调用。- 仿函数提供了一种比普通函数更灵活的方式来实现一些特定的算法逻辑，因为它可以保存状态。
- 在STL中，很多算法的参数可以接受仿函数，用来定义它们的行为。
struct MyFunctor { void operator()(int value) const { std::cout << "Value: " << value << std::endl; } };总结来说，函数对象、谓词和仿函数都是为了在STL中增加灵活性和可复用性而设计的概念。它们允许开发人员以多种方式定制算法的行为，使得STL成为C++中强大的工具之一
326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
