C++函数对象实现重载operator()示例-C++-PHP中文网

函数对象是重载了operator()的类实例，可像函数一样调用，能携带状态且与标准库算法配合实现行为参数化，相比函数指针更灵活安全，适用于需要状态保持或泛型编程的场景。

c++函数对象实现重载operator()示例

C++的函数对象，说白了，就是那些重载了

operator()

登录后复制

的类的实例。它们让一个普通的对象，也能像函数一样被调用。在我看来，这是C++一个特别巧妙的设计，它模糊了“数据”和“行为”的界限，让你可以把行为封装进一个对象里，然后像传递数据一样传递它，或者像调用函数一样执行它。

解决方案

要实现一个函数对象，核心就是定义一个类，并在其中重载圆括号运算符

operator()

登录后复制

。这个运算符可以有任何参数列表和返回类型，就像一个普通函数一样。

举个最简单的例子，我们来创建一个能判断一个数字是否是偶数的函数对象：

#include <iostream>
#include <vector>
#include <algorithm> // 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<int> 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++标准库，尤其是

<algorithm>

登录后复制

头文件里的那些通用算法，简直是函数对象的主战场。它们被设计成可以接受各种“可调用对象”（Callable Objects），而函数对象就是其中最重要的一种。高效利用函数对象，很多时候就是指如何把它们作为参数传递给这些算法，以实现定制化的行为。

我们来举几个经典的例子：

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

查看详情

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<Person> 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<int> 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
```
  登录后复制
  是你的救星。