Lambda 表达式全解：从捕获语义到闭包对象

Lambda 是 C++11 引入的最具表现力的特性之一。它让"在现场定义一个可调用对象"从手写函数对象的繁琐中解放出来，直接改变了我们使用 STL 算法、注册回调、写异步代码的方式。

但 Lambda 的底层模型并不简单。"捕获"到底意味着什么？泛型 Lambda 的 auto 和模板 Lambda 的模板参数有什么区别？Lambda 对象在内存中究竟长什么样？本文从编译器视角出发，把这些问题一一拆解。

1. 语法糖的背后：Lambda 就是函数对象

核心认知：Lambda 表达式只是编译器替你生成匿名函数对象的语法糖。

auto less = [](int a, int b) { return a < b; };

编译器生成的等价代码大致是：

struct __anonymous_less {
    auto operator()(int a, int b) const -> bool {
        return a < b;
    }
};
__anonymous_less less;

Lambda 的类型是独一无二的、编译器生成的、未指定的——即使用相同签名定义的两个 Lambda，类型也不同。这就是为什么你只能用 auto 接收它，或者用 std::function 进行类型擦除（后者有分配和虚调开销）。

2. 捕获列表：五种种捕获方式

2.1 值捕获 [x]

int x = 42;
auto f = [x] { return x + 1; };  // x 被拷贝到闭包对象内部
x = 0;
f();  // 返回 43，闭包内的 x 不受外部影响

值捕获发生在 Lambda 构造时，不是调用时。捕获的成员是 const 的（除非 Lambda 标记为 mutable）。

2.2 引用捕获 [&x]

int x = 42;
auto f = [&x] { return x + 1; };  // 闭包内持有 x 的引用
x = 10;
f();  // 返回 11

危险场景：Lambda 的存活时间超过被引用变量。

std::function<int()> create_dangling() {
    int local = 100;
    return [&local] { return local; };  // 危险！local 已经析构
}

2.3 隐式捕获 [=] / [&]

auto f = [=] { return a + b + c; };   // 用到的变量全部值捕获
auto g = [&] { return a + b + c; };   // 用到的变量全部引用捕获

[=] 曾经被广泛推荐为"安全的默认选择"，但实际上它鼓励不加思考的捕获。推荐显式列出捕获变量，或至少对非局部变量保持敏感。

2.4 初始化捕获 [x = expr] (C++14)

这是 C++14 最重要的 Lambda 增强：

// 移动捕获：unique_ptr 不能拷贝，只能 move
auto ptr = std::make_unique<int>(42);
auto f = [p = std::move(ptr)] { return *p; };
// ptr 现在是 nullptr，p 是闭包的成员

// 表达式捕获
auto g = [vec = std::vector<int>{1,2,3}] { return vec.size(); };

初始化捕获本质上是在闭包对象中声明并初始化了一个成员变量，右侧表达式的作用域是 Lambda 定义处的外部作用域。

2.5 [this] vs [*this] (C++17 vs C++20)

struct Widget {
    int value = 42;
    auto get_lambda() {
        // C++11: [=] 隐式捕获 this
        // C++17: [*this] 拷贝整个对象
        return [*this] { return value; };  // Widget 被拷贝到闭包
    }
};

[*this] 解决了异步场景下 this 可能悬空的问题——既然不能保证 this 存活，干脆把整个对象拷进闭包。

3. mutable：打破 operator() 的 const

默认情况下，Lambda 的 operator() 是 const 的，值捕获的变量不可修改：

auto f = [x = 0]() mutable { return ++x; };
f();  // 1
f();  // 2
f();  // 3

mutable 让编译器去掉 operator() 的 const 限定符。注意它不影响引用捕获——对引用加 const 只是让引用本身不可变，引用的对象永远可变。

4. 泛型 Lambda (C++14) vs 模板 Lambda (C++20)

C++14 引入了泛型 Lambda，用 auto 标记参数类型：

auto add = [](auto a, auto b) { return a + b; };
// 等价于手写函数对象模板
// struct { template<typename T, typename U> auto operator()(T a, U b) { return a + b; } };
add(1, 2);        // int + int
add(1.5, 2.3);    // double + double
add(1, 2.5);      // int + double，返回 double

但泛型 Lambda 有一个限制：所有 auto 参数必须各自独立推导，它们之间没有约束关系：

// 泛型 Lambda 无法表达"两个参数类型必须相同"
auto ambiguous = [](auto a, auto b) { return a + b; };
ambiguous(1, 1.5);  // 没问题，但可能不是你想要的一致类型

C++20 的模板 Lambda 解决了这个问题：

auto explicit_add = []<typename T>(T a, T b) { return a + b; };
// explicit_add(1, 1.5);  // 编译错误！推导矛盾
explicit_add(1, 2);       // OK

// 还可以获取模板参数的类型
auto get_value = []<typename T>(std::vector<T> const& v) -> T {
    return v.empty() ? T{} : v[0];
};

模板 Lambda 的另一个关键用途：在 requires 子句中约束参数：

auto numeric_add = []<typename T>(T a, T b) requires std::is_arithmetic_v<T> {
    return a + b;
};

5. 闭包对象的内存模型

5.1 无捕获 Lambda

无捕获的 Lambda 不占任何成员空间，且可以隐式转换为函数指针：

auto f = [](int x) { return x * 2; };
static_assert(sizeof(f) == 1);  // 最小可能大小

int (*fp)(int) = f;            // 隐式转换为函数指针
int result = fp(42);           // 直接调用，零开销

5.2 有捕获 Lambda

有捕获的 Lambda 就是一个带着成员变量的结构体：

int a = 10; double b = 3.14;
auto f = [a, b](int x) { return a * x + b; };

// sizeof(f) ≈ sizeof(int) + sizeof(double) = 12~16（考虑对齐）
// 内存布局：{ int a; double b; }

每个被捕获的变量都成为闭包对象的一个非静态数据成员，按声明顺序排列（但不保证内存布局中的顺序）。

6. Lambda 的实践模式

6.1 立即执行表达式 (IIFE)

const auto config = [] {
    auto cfg = load_default_config();
    cfg.apply_overrides();
    cfg.validate();
    return cfg;  // 只暴露最终结果，中间状态不泄露
}();

比写一个单独的 init 函数更整洁——初始化逻辑紧邻变量，且中间变量不污染外部作用域。

6.2 算法中的 projection

std::sort(people.begin(), people.end(),
          [](const Person& a, const Person& b) { return a.age < b.age; });

这是 C++11 Lambda 最核心的使用场景——无需手写函数对象。C++20 的 Ranges 更进一步，把 projection 作为一等公民支持（后面 Ranges 专题详述）。

6.3 std::function 的开销

std::function<int(int)> f = [x = 5](int y) { return x + y; };

std::function 使用类型擦除 + 小对象优化（SBO）。小闭包不分配堆内存，大闭包触发堆分配。std::function 的调用是间接调用（虚表指针），无法内联。如果你需要存储"任意可调用对象"且调用不是热点，它很合适；如果性能敏感，用模板避免类型擦除。

7. 常见陷阱

捕获与生命周期

auto create_printer() {
    std::string name = "hello";
    return [&name] { std::cout << name; };  // 悬空引用！
}  // name 已析构

auto create_printer_safe() {
    std::string name = "hello";
    return [name] { std::cout << name; };   // 值捕获，安全
}

默认捕获的隐性 this

struct Widget {
    int x = 5;
    auto make_lambda() {
        return [=] { return x; };  // 实际捕获的是 this，不是 x 的拷贝！
    }
};
// 离开 make_lambda 后 Widget 可能析构 → this 悬空

[=] 对于成员变量不会值捕获，而是捕获 this。C++20 的 [=, this] 明确了这个意图，[=, *this] 才真正拷贝对象。

总结

特性	标准版本	要点
基本 Lambda	C++11	函数对象的语法糖，operator() 默认 const
初始化捕获	C++14	[p = std::move(ptr)] 支持 move-only 类型
泛型 Lambda	C++14	[](auto a, auto b) ，参数独立推导
[*this]	C++17	拷贝整个对象进闭包
模板 Lambda	C++20	[]<typename T>(T a, T b) 约束参数关系

Lambda 的本质从未变过：它只是一个编译器代写的函数对象。理解这一点，捕获列表就不过是成员变量的声明语法，mutable 不过是去掉 const，泛型 Lambda 不过是成员模板。一切变得理所当然。