函数对象的本质：重载 operator() 的类，状态保持能力

好，咱们今天聊一个很实在的话题——函数对象。

说白了，函数对象就是一个重载了 operator() 的类。你可能会问：这不就是个能像函数一样调用的对象吗？对，但它的意义远不止于此。

我记得刚入行那会儿，看到同事写了个类，里面有个 operator()，我当时心想：这不就是换个写法吗？后来真正用上了，才发现这东西的威力。尤其是状态保持能力，这是普通函数做不到的。

什么是函数对象？

先看一个最简单的例子：

class Adder {
public:
    int operator()(int a, int b) const {
        return a + b;
    }
};

// 使用
Adder add;
int result = add(3, 4);  // result = 7

你看，Adder 是一个类，但它可以像函数一样被调用。这就是函数对象的核心——重载 operator()。

我个人习惯把函数对象叫做「仿函数」，虽然这个叫法在 C++ 社区里有点老了，但意思是一样的。

为什么需要函数对象？

你可能会想：我直接用普通函数不就行了？何必多此一举？

嗯，这里有个关键点：普通函数没有状态。你调用一个函数，它执行完就结束了，下次调用又是从头开始。但函数对象不一样——它是一个对象，可以拥有成员变量。

举个例子：

class Counter {
private:
    int count_ = 0;
public:
    int operator()() {
        return ++count_;
    }
};

Counter counter;
std::cout << counter() << std::endl;  // 输出 1
std::cout << counter() << std::endl;  // 输出 2
std::cout << counter() << std::endl;  // 输出 3

看到了吗？每次调用，count_ 都在递增。这就是状态保持。普通函数做不到这一点——除非你用全局变量，但那又引入了别的问题。

状态保持能力的实际应用

我在项目中遇到过这样一个场景：需要统计一组数据中大于某个阈值的元素个数。用函数对象来实现，非常优雅：

class GreaterThan {
private:
    int threshold_;
public:
    explicit GreaterThan(int threshold) : threshold_(threshold) {}

    bool operator()(int value) const {
        return value > threshold_;
    }
};

std::vector<int> data = {1, 5, 8, 3, 10, 2};
int count = std::count_if(data.begin(), data.end(), GreaterThan(5));
// count = 2 (8 和 10)

你想想看，如果我用普通函数，阈值怎么传？要么用全局变量，要么用 std::bind 或者 lambda。但函数对象直接把阈值封装在对象内部，干净利落。

函数对象 vs 函数指针

咱们来做个对比：

特性	函数指针	函数对象
状态保持	❌ 不能	✅ 可以
内联优化	❌ 编译器难优化	✅ 容易内联
灵活性	低	高（可包含数据）
性能	有间接调用开销	通常更快

说白了，函数对象在性能上往往更优。因为编译器知道具体调用哪个 operator()，可以直接内联。而函数指针是间接调用，编译器很难优化。

函数对象与 STL 算法

STL 算法大量使用函数对象。比如 std::sort 可以接受一个比较器：

struct Descending {
    bool operator()(int a, int b) const {
        return a > b;
    }
};

std::vector<int> nums = {3, 1, 4, 1, 5, 9};
std::sort(nums.begin(), nums.end(), Descending());
// nums = {9, 5, 4, 3, 1, 1}

这里 Descending 就是一个函数对象。它没有状态，但胜在清晰、可内联。

避坑指南：函数对象的拷贝问题

我曾经踩过一个坑——函数对象被拷贝了多次，导致状态丢失。来看个例子：

class Accumulator {
private:
    int sum_ = 0;
public:
    void operator()(int value) {
        sum_ += value;
    }
    int getSum() const { return sum_; }
};

std::vector<int> data = {1, 2, 3, 4, 5};
Accumulator acc;
std::for_each(data.begin(), data.end(), acc);
std::cout << acc.getSum() << std::endl;  // 输出 0！

为什么会这样？因为 std::for_each 内部是按值传递函数对象的，acc 被拷贝了，原始对象的状态根本没变。

解决办法有两个：

• 使用 std::ref 包装：std::for_each(data.begin(), data.end(), std::ref(acc));
• 或者让 operator() 返回引用：Accumulator& operator()(int value) { ... return *this; }

函数对象与 Lambda 的关系

说到这儿，你可能已经想到了 Lambda 表达式。没错，Lambda 本质上就是一个匿名函数对象。编译器会把 Lambda 展开成一个类，这个类重载了 operator()。

比如：

auto lambda = [threshold](int value) { return value > threshold; };

编译器会生成类似这样的代码：

class __lambda_xxx {
private:
    int threshold;
public:
    __lambda_xxx(int t) : threshold(t) {}
    bool operator()(int value) const {
        return value > threshold;
    }
};

所以，理解函数对象，就是理解 Lambda 的底层原理。你写 Lambda 的时候，其实就是在写一个函数对象，只不过编译器帮你把那些模板代码都省了。

函数对象的高级用法：多态函数对象

函数对象还可以结合继承实现多态。比如：

class FilterBase {
public:
    virtual bool operator()(int value) const = 0;
    virtual ~FilterBase() = default;
};

class EvenFilter : public FilterBase {
public:
    bool operator()(int value) const override {
        return value % 2 == 0;
    }
};

class OddFilter : public FilterBase {
public:
    bool operator()(int value) const override {
        return value % 2 != 0;
    }
};

这种设计在策略模式中很常见。你可以把不同的 Filter 对象传给同一个函数，实现不同的行为。

小结

函数对象的本质，说白了就是重载 operator() 的类。它的核心优势在于：

• 状态保持：可以携带数据，跨调用保持状态
• 性能更好：编译器容易内联，没有间接调用开销
• 灵活性高：可以包含构造函数、成员函数、继承等
• 与 STL 无缝配合：是泛型编程的重要基石

我个人觉得，函数对象是理解 C++ 泛型编程和 Lambda 表达式的关键一步。你把它搞明白了，后面学 Lambda 就会觉得「哦，原来如此」。

嗯，函数对象就是这么个东西。它不复杂，但很实用。你写 C++ 越久，就越会发现它的价值。