深入理解仿函数（Functors）：从概念到实践

1. 什么是仿函数？

仿函数（Functor），也称为函数对象（Function Object），是C++中一种特殊的对象，它可以像函数一样被调用。本质上，仿函数是一个类或结构体，它重载了函数调用运算符operator()。

仿函数是STL中的重要概念之一，可以用于 实现自定义的比较、排序、映射 等操作，使代码更具灵活性和可重用性。

template<class T>
class Less 
{
public:bool operator()(const T& x, const T& y) {return x < y;}
};

2. 仿函数与普通函数的区别

特性	普通函数	仿函数
状态保持	无	可以保持状态
内联优化	可能	更易被编译器内联
多台支持	有限	支持完整面向对象特性
作为模版参数	仅函数指针	可直接作为模版参数

3. 标准库中的仿函数

C++标准库提供了许多有用的仿函数，主要位于 “functional” 头文件中：

• 算术运算：plus, minus, multiplies, divides, modulus, negate
• 比较运算：equal_to, not_equal_to, greater, less, greater_equal, less_equal
• 逻辑运算：logical_and, logical_or, logical_not
• 位运算：bit_and, bit_or, bit_xor

这里我们用std::plus()来创建一个加法仿函数，并将其存储在std::function对象中，然后可以像函数一样去调用它。

#include <iostream>
#include <functional>int main() 
{std::function<int(int, int)> myFunc = std::plus<int>(); // 使用标准库的仿函数int result = myFunc(5, 3); // 调用仿函数std::cout << "Result: " << result << std::endl;return 0;
}

4. 仿函数的优势

4.1 状态保持

仿函数可以包含成员变量，因此可以在调用之间保持状态：

class Counter {int count = 0;
public:void operator()(int x) {std::cout << "Element #" << ++count << ": " << x << "\n";}
};int main() {std::vector<int> v = {10, 20, 30};std::for_each(v.begin(), v.end(), Counter());
}

4.2 可定制性

通过模板和继承，仿函数可以实现高度可定制的行为：

在这个示例中，我们创建了两个不同的仿函数，一个用于加法（MyAdditionFunc），一个用于减法（ MySubtractionFunc ），它们可以根据需要进行切换。

class MyAdditionFunc 
{
public:int operator()(int a, int b) {return a + b;}
};class MySubtractionFunc 
{
public:int operator()(int a, int b) {return a - b;}
};int main() 
{MyAdditionFunc add;MySubtractionFunc subtract;int result1 = add(5, 3);        // 8int result2 = subtract(5, 3);   // 2std::cout << "Result of addition: " << result1 << std::endl;std::cout << "Result of subtraction: " << result2 << std::endl;return 0;
}

4.3 性能优势

在某些情况下，使用仿函数可能会导致性能开销，因为它们引入了额外的函数调用。与普通函数相比，仿函数可能会有一些微小的性能损失。但在 绝大多数情况下，这种性能损失非常小，通常可以忽略不计。在性能要求非常高的特定应用中，可以使用内联函数或其他优化手段来减小性能损失。

5. 现代C++中的仿函数

5.1 Lambda表达式

C++11引入的 Lambda 表达式本质上是匿名仿函数的语法糖：

auto add = [](int a, int b) { return a + b; };
std::cout << add(3, 4);  // 输出7

5.2 通用仿函数

使用模板和 auto 参数使仿函数更通用：

struct GenericAdd {template <typename T, typename U>auto operator()(T t, U u) const {return t + u;}
};int main() {GenericAdd add;std::cout << add(3, 4.5);  // 输出7.5
}

6. 仿函数的高级应用（使用C++2020标准库及以上版本）

6.1 函数组合

仿函数可以组合形成更复杂的行为：

template <typename F, typename G>
class Compose {F f;G g;public:// 构造函数：存储 f 和 gCompose(F f, G g): f(f), g(g){}// operator() 允许对象像函数一样被调用template <typename X>auto operator()(X x) const {return f(g(x)); // 先计算 g(x)，再计算 f(g(x))}
};int main() {auto square = [](int x) { return x * x; };auto increment = [](int x) { return x + 1; };// Compose(f, g) 表示 f(g(x))，即先执行 g，再执行 fauto square_then_increment = Compose(increment, square); // 先平方，再加 1std::cout << square_then_increment(3); // 输出 10 (3² + 1)// 如果想先 increment 再 square，可以交换顺序auto increment_then_square = Compose(square, increment); // 先加 1，再平方std::cout << "\n" << increment_then_square(3); // 输出 16 ((3 + 1)²)
}

6.2 惰性求值

仿函数可以实现惰性求值模式：

class LazyValue {// function 可以将任何类型的可调用元素 （例如函数和函数对象 ）包装到可复制对象中的类，并且其类型仅取决于其调用签名（而不取决于可调用元素类型本身）。std::function<int()> generator;// optional 管理一个可选 的容纳值，既可以存在也可以不存在的值。mutable std::optional<int> cache;
public:LazyValue(std::function<int()> g) : generator(g) {}operator int() const {if (!cache) {cache = generator();}return *cache;}
};int expensive_computation() {// 模拟耗时计算// sleep_for 当前线程的执行将停止，直到从现在开始至少经过 rel_time 为止。其他线程继续执行。std::this_thread::sleep_for(std::chrono::seconds(1));return 42;
}int main() {// 延迟42毫秒再运行程序LazyValue lazy(expensive_computation);// 计算尚未发生std::cout << "Value: " << lazy;  // 此时进行计算cout << endl;std::cout << "Again: " << lazy;  // 使用缓存值cout << endl;
}

7. 总结

仿函数是C++中强大而灵活的工具，它们：

• 比普通函数更强大（可以保持状态）
• 比函数指针更安全（类型安全）
• 比虚函数更高效（静态多态）
• 与现代C++特性（lambda、模板）完美结合

掌握仿函数将显著提升你的C++编程能力，特别是在泛型编程和标准库使用方面。