函数对象与lambda表达式：从仿函数到现代C++的优雅进化

说实话，我刚入行那会儿，C++98还是主流。那时候想给std::sort传个自定义排序规则，得老老实实写个函数对象——也就是所谓的仿函数。现在回想起来，那段日子虽然有点原始，但正是这些基础让我后来理解lambda时格外通透。

这一章，我们就来聊聊函数对象和lambda表达式。我会从最基础的仿函数定义讲起，再到lambda这个语法糖，最后用实战收尾。你想想看，掌握了这些，你在STL算法面前就真正有了「定制」的能力。

1. 函数对象（仿函数）的本质

函数对象，说白了就是一个重载了operator()的类实例。它之所以叫「仿函数」，是因为它用起来像函数，但本质上是个对象。

// 一个简单的仿函数
struct MyComparator {
    bool operator()(int a, int b) const {
        return a > b;  // 降序排列
    }
};

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

为什么不用普通函数？嗯，这里有个关键点：仿函数可以携带状态。普通函数做不到这一点，除非你用全局变量——但那玩意儿在多线程环境下就是个灾难。

我在项目中遇到过这样一个场景：需要根据用户配置的排序方向（升序/降序）来排序。用仿函数，我只需要在构造函数里传一个bool值进去，干净利落。

struct FlexibleComparator {
    bool ascending;
    
    FlexibleComparator(bool asc) : ascending(asc) {}
    
    bool operator()(int a, int b) const {
        return ascending ? a < b : a > b;
    }
};

// 使用
std::sort(data.begin(), data.end(), FlexibleComparator(false));  // 降序

2. lambda表达式：语法糖背后的真相

C++11引入了lambda表达式。我第一次看到它时，心里想的是：「这不就是仿函数的语法糖吗？」后来仔细研究才发现，lambda本质上就是编译器帮你生成了一个匿名的仿函数对象。

来看最基本的lambda语法：

[捕获列表](参数列表) -> 返回类型 {
    函数体
}

其中返回类型可以省略，编译器会自动推导。大多数情况下你都不需要写它。

// 最简单的lambda
auto cmp = [](int a, int b) { return a > b; };
std::sort(data.begin(), data.end(), cmp);

// 或者直接内联
std::sort(data.begin(), data.end(), [](int a, int b) { return a > b; });

3. 捕获列表详解：值捕获、引用捕获、混合捕获

捕获列表是lambda最灵活也最容易出错的地方。它决定了lambda内部能访问外部作用域的哪些变量，以及如何访问。

捕获方式	语法	说明
值捕获	[x]	捕获x的副本，lambda内部修改不影响外部
引用捕获	[&x]	捕获x的引用，修改会反映到外部
隐式值捕获	[=]	捕获所有用到的外部变量（按值）
隐式引用捕获	[&]	捕获所有用到的外部变量（按引用）
混合捕获	[=, &x]	默认值捕获，但x按引用捕获
初始化捕获	[x = std::move(y)]	C++14起支持，可以捕获移动语义的变量

我曾经踩过一个坑：在异步回调里用了引用捕获，结果lambda执行时那个变量已经销毁了。程序崩溃得莫名其妙。从那以后，只要lambda的生命周期可能超过当前作用域，我一定用值捕获。

int threshold = 10;
// 安全的做法：值捕获
auto safe_lambda = [threshold](int value) {
    return value > threshold;
};

// 危险的用法：引用捕获，如果lambda被延迟执行
auto dangerous_lambda = [&threshold](int value) {
    return value > threshold;  // threshold可能已经失效！
};

4. mutable关键字：打破const的限制

默认情况下，lambda的operator()是const的。这意味着你不能修改值捕获的变量。如果你非要改，就得加上mutable关键字。

int count = 0;
auto counter = [count]() mutable {
    return ++count;  // 没有mutable会编译错误
};

std::cout << counter() << std::endl;  // 输出1
std::cout << counter() << std::endl;  // 输出2
std::cout << count << std::endl;      // 输出0，外部count不受影响

我个人很少用mutable。为什么？因为一旦你需要修改捕获的值，往往意味着你的lambda逻辑变复杂了。这时候我倾向于把它拆成一个独立的仿函数，代码更清晰。

5. 实战：自定义排序规则

理论说完了，我们来点实际的。假设你有一个学生信息结构体，需要按不同规则排序。

struct Student {
    std::string name;
    int age;
    double score;
};

std::vector<Student> students = {
    {"Alice", 20, 92.5},
    {"Bob",   19, 85.0},
    {"Charlie", 21, 95.5},
    {"David",  20, 88.0}
};

需求来了：先按分数降序，分数相同则按年龄升序。用lambda写起来非常直观：

std::sort(students.begin(), students.end(), 
    [](const Student& a, const Student& b) {
        if (a.score != b.score)
            return a.score > b.score;  // 分数降序
        return a.age < b.age;          // 年龄升序
    });

如果排序规则需要从外部传入呢？比如用户选择按「分数」或「年龄」排序：

enum class SortBy { Score, Age };
enum class SortOrder { Ascending, Descending };

void sortStudents(std::vector<Student>& students, 
                  SortBy by, SortOrder order) {
    std::sort(students.begin(), students.end(),
        [by, order](const Student& a, const Student& b) {
            auto compare = [order](double x, double y) {
                return order == SortOrder::Ascending ? x < y : x > y;
            };
            
            if (by == SortBy::Score)
                return compare(a.score, b.score);
            else
                return compare(a.age, b.age);
        });
}

6. 知识体系总览

下面这张图帮你梳理本章的核心脉络：

从图中你可以看到，函数对象和lambda都能实现自定义排序规则。区别在于：函数对象适合逻辑复杂、需要复用的场景；lambda适合简单、一次性的场景。没有谁优谁劣，关键看上下文。

好了，这一章的内容就到这里。函数对象和lambda是STL算法灵活性的基石。你想想看，没有它们，std::sort只能按升序排，那得多死板？掌握了这些，你就能让STL算法真正为你所用。