函数对象是重载了operator()的类实例，可像函数一样调用，能携带状态且与标准库算法配合实现行为参数化，相比函数指针更灵活安全，适用于需要状态保持或泛型编程的场景。
C++的函数对象，说白了，就是那些重载了
operator()
的类的实例。它们让一个普通的对象，也能像函数一样被调用。在我看来，这是C++一个特别巧妙的设计，它模糊了“数据”和“行为”的界限，让你可以把行为封装进一个对象里，然后像传递数据一样传递它，或者像调用函数一样执行它。
解决方案
要实现一个函数对象，核心就是定义一个类，并在其中重载圆括号运算符
operator()
。这个运算符可以有任何参数列表和返回类型，就像一个普通函数一样。
举个最简单的例子，我们来创建一个能判断一个数字是否是偶数的函数对象：
#include #include #include // for std::for_each, std::sort// 1. 定义一个类class IsEven {public: // 2. 重载 operator() bool operator()(int num) const { return num % 2 == 0; }};// 另一个例子：一个可以累加的函数对象，带有内部状态class Accumulator {private: long long sum_ = 0; // 内部状态public: void operator()(int num) { sum_ += num; } long long get_sum() const { return sum_; }};int main() { // 使用 IsEven 函数对象 IsEven checkEven; // 创建一个函数对象实例 if (checkEven(4)) { // 像调用函数一样调用它 std::cout << "4 is even." << std::endl; } // 将 IsEven 应用到容器中 (例如，配合标准库算法) std::vector numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; std::cout << "Even numbers in vector: "; for (int n : numbers) { if (checkEven(n)) { // 再次调用 std::cout << n << " "; } } std::cout << std::endl; // 使用 Accumulator 函数对象 Accumulator acc; std::for_each(numbers.begin(), numbers.end(), acc); // std::for_each 会对每个元素调用 acc(num) std::cout << "Sum of numbers: " << acc.get_sum() << std::endl; // 获取累加结果 return 0;}
这段代码展示了函数对象的基本结构和两种典型用法：一种是无状态的判断逻辑，另一种是带有内部状态的累加器。关键在于
operator()
的重载，它让类的实例变得“可调用”。
立即学习“C++免费学习笔记（深入）”；
为什么我们需要函数对象？它们和普通函数指针有什么不同？
我个人觉得，函数对象之所以重要，是因为它解决了函数指针的一些固有局限性。最初接触C++，我们学习函数指针，觉得那玩意儿挺酷，能把函数当参数传。但用着用着，你就会发现它有几个痛点：
首先，函数指针无法携带状态。一个普通函数指针指向的函数，它执行的逻辑是固定的，不能在调用之间记住任何信息。比如，你想传递一个比较器给
std::sort
，这个比较器需要根据外部的一个阈值来排序，函数指针就无能为力了。你没法给它一个“上下文”或者“配置”。函数对象则不同，它是一个类的实例，可以有成员变量。这些成员变量就是它的“状态”，让它的行为可以根据这些状态动态调整。上面
Accumulator
的例子就很好地说明了这一点，
sum_
成员变量就是它的状态。
其次，类型安全和泛型编程的适配性。函数指针在泛型编程，特别是模板中，用起来会有些别扭。它们的类型签名必须完全匹配，这在复杂模板元编程中可能成为障碍。而函数对象，因为它们是类类型，可以被模板参数完美地推导和处理，这使得它们与C++的模板机制配合得天衣无缝。
std::sort
接受的就是一个函数对象作为比较器，而不是一个裸的函数指针。编译器可以在编译期对函数对象进行内联优化，理论上性能会更好。
说实话，有时候我觉得函数对象就像是给函数套了一个“壳”，这个壳不仅能让函数“记住”东西，还能让它更好地融入C++的类型系统和面向对象范式。它提供了一种比函数指针更强大、更灵活的封装行为的方式。
如何在C++标准库算法中高效利用函数对象？
C++标准库，尤其是
头文件里的那些通用算法，简直是函数对象的主战场。它们被设计成可以接受各种“可调用对象”（Callable Objects），而函数对象就是其中最重要的一种。高效利用函数对象，很多时候就是指如何把它们作为参数传递给这些算法，以实现定制化的行为。
我们来举几个经典的例子：
std::sort
的自定义比较器：当你想对一个容器里的元素进行非默认的排序时，你需要提供一个比较规则。这个规则就常常由一个函数对象来承载。
struct Person { std::string name; int age;};// 按照年龄降序排序的函数对象struct ComparePersonByAgeDesc { bool operator()(const Person& p1, const Person& p2) const { return p1.age > p2.age; // 年龄大的排在前面 }};int main() { std::vector people = { {"Alice", 30}, {"Bob", 25}, {"Charlie", 35} }; std::sort(people.begin(), people.end(), ComparePersonByAgeDesc()); std::cout << "Sorted by age (desc):" << std::endl; for (const auto& p : people) { std::cout << p.name << " (" << p.age << ")" << std::endl; } return 0;}
这里
ComparePersonByAgeDesc
就是一个函数对象，它封装了比较逻辑。
std::sort
会反复调用它的
operator()
来决定元素的顺序。
std::for_each
的元素操作：如果你想对容器中的每个元素执行某个操作，
std::for_each
是个好选择，它也经常搭配函数对象使用。
// 一个打印并修改元素的函数对象class PrintAndIncrement {private: std::string prefix_;public: explicit PrintAndIncrement(const std::string& prefix) : prefix_(prefix) {} void operator()(int& num) const { // 注意这里是引用，可以修改 std::cout << prefix_ << num < "; num++; // 修改元素 std::cout << num << std::endl; }};int main() { std::vector values = {10, 20, 30}; std::cout << "Original values: "; for (int v : values) std::cout << v << " "; std::cout << std::endl; // 使用带状态的函数对象 std::for_each(values.begin(), values.end(), PrintAndIncrement("Value: ")); std::cout << "Modified values: "; for (int v : values) std::cout << v << " "; std::cout << std::endl; return 0;}
PrintAndIncrement
这个函数对象，通过构造函数接收一个前缀，并将其存储为成员变量
prefix_
。这使得它在执行
operator()
时，能够利用这个状态。
函数对象在标准库算法中的应用，真正体现了“行为参数化”的思想。它让算法本身保持通用性，而具体的行为则由我们提供的函数对象来定义，大大增强了代码的灵活性和复用性。
函数对象、Lambda表达式和std::function：我该如何选择？
这三者在C++中都代表了“可调用对象”，但它们各有侧重和适用场景。在我看来，它们是C++在处理“行为”这个概念上，从传统到现代，一步步演进的结果。
函数对象 (Function Objects / Functors – 显式类定义)
优点：清晰且可重用： 当你的逻辑比较复杂，或者需要在多个地方复用相同的、带有状态的行为时，定义一个显式的类是最清晰的方式。它的接口明确，易于理解和维护。类型安全： 编译器在编译时就能检查类型匹配。性能： 如果
operator()
足够简单，编译器通常能将其内联，避免函数调用开销，达到接近手动优化的性能。缺点：冗余： 对于一些简单、一次性的操作，定义一个完整的类显得过于冗长。选择时机： 当你需要一个复杂的、有状态的、需要在多处复用，并且其生命周期可能比当前作用域更长的行为时，或者当你想利用继承和多态来组织行为时（虽然这不常见），显式函数对象是首选。
Lambda 表达式
优点：简洁和内联： 这是它最大的优势。对于简单、一次性的操作，直接在需要的地方定义，代码非常紧凑。捕获列表： 能够方便地捕获周围作用域的变量，这让它天生就“有状态”，解决了函数指针不能携带状态的问题。它其实是编译器为你自动生成的一个匿名函数对象。缺点：匿名性： 除非你把它赋值给一个
auto
变量或
std::function
，否则你无法直接通过名字引用它。复杂性： 如果Lambda体过于庞大，会影响可读性。选择时机： 大多数情况下，尤其是在C++11及更高版本中，Lambda表达式是处理局部、一次性或简单行为的首选。比如，作为
std::sort
或
std::for_each
的参数，它比显式函数对象简洁得多。
std::function
优点：类型擦除： 它可以存储任何可调用对象，无论是函数指针、函数对象、Lambda表达式，甚至是成员函数指针。它提供了一个统一的接口，让你不必关心底层可调用对象的具体类型。多态性： 当你需要一个参数可以接受多种不同类型的可调用对象时，
std::function
是完美的解决方案。缺点：运行时开销： 由于类型擦除的机制，
std::function
通常会引入一些运行时开销（例如，堆内存分配和虚函数调用），这可能比直接调用函数对象或Lambda慢。不适合作为模板参数： 如果你是在写模板代码，通常直接使用模板参数
typename F
来表示可调用对象更高效，而不是强制使用
std::function
。选择时机： 当你需要将可调用对象作为参数传递给一个函数，但这个函数不应该关心可调用对象的具体类型时（例如，作为回调函数），或者你需要将不同类型的可调用对象存储在一个容器中时，
std::function
是你的救星。
所以，我的选择策略通常是这样的：
对于简单、局部、一次性的逻辑，Lambda 几乎是我的默认选择。如果逻辑变得复杂、有状态，并且需要被多次复用，或者需要清晰的命名和接口，我会把它重构成一个显式的函数对象类。如果我需要一个“万能”的函数容器，可以存储各种各样的可调用对象，或者作为回调接口，那么
std::function
就是最合适的。
它们不是互相排斥的，很多时候是互补的。比如，一个Lambda表达式在底层就是编译器生成的一个函数对象。而
std::function
能够包装Lambda和显式函数对象。理解它们的特点和权衡，能帮助你写出更高效、更灵活也更易读的C++代码。
以上就是C++函数对象实现 重载operator()示例的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1472817.html
微信扫一扫 
支付宝扫一扫 
