理解lambda表达式的闭包性质

原创于 2025-09-05 08:19:29 发布 · 564 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++

C++ 专栏收录该内容

116 篇文章

订阅专栏

在 C++ 中，lambda 表达式的闭包性质（closure property）是指：lambda 不仅包含一段可执行的代码逻辑，还“携带”了其创建时所处作用域中的外部变量信息（通过捕获列表捕获），形成一个“函数 + 状态”的结合体。这种结合体被称为闭包（closure），它能“记住”创建时的环境，并在后续调用时使用这些环境信息。

核心理解：闭包 = 代码逻辑 + 捕获的状态

普通函数（或函数指针）仅包含代码逻辑，无法直接访问定义它的作用域之外的局部变量。而 lambda 表达式通过捕获列表（[capture-list]）捕获外部变量，将这些变量的状态“打包”到自身中，从而形成一个带状态的可调用对象——这就是闭包的本质。

例如，以下 lambda 捕获了外部变量 base，形成了一个“记住 base 值”的闭包：

#include <iostream>
#include <functional>

std::function<int(int)> make_adder(int base) {
    // lambda 捕获 base（按值），形成闭包
    return [base](int x) { return base + x; }; 
}

int main() {
    // 创建闭包：捕获 base=5
    auto add5 = make_adder(5);
    // 创建另一个闭包：捕获 base=10
    auto add10 = make_adder(10);
    
    // 闭包“记住”了各自的 base 值
    std::cout << add5(3) << std::endl;  // 5 + 3 = 8
    std::cout << add10(3) << std::endl; // 10 + 3 = 13
    return 0;
}

make_adder 函数返回的 lambda 不仅包含 base + x 的代码逻辑，还“携带”了创建时的 base 值（5 或 10）。
即使 make_adder 函数已执行结束（base 变量的作用域已销毁），返回的闭包仍能使用捕获的 base 副本——这就是闭包“记住环境”的能力。

闭包性质的具体体现

1. 捕获的状态与创建环境绑定

lambda 捕获的变量状态以创建时的环境为准（而非调用时），这是闭包“绑定环境”的核心特征。

值捕获：闭包存储外部变量的副本，后续外部变量的修改不会影响闭包中的副本。
引用捕获：闭包存储外部变量的引用，闭包的状态会随外部变量的修改而变化（本质是绑定了变量的地址）。

#include <iostream>

int main() {
    int a = 10;
    
    // 闭包1：按值捕获a（副本为10）
    auto val_closure = [a]() { std::cout << "val: " << a << " "; };
    
    // 闭包2：按引用捕获a（绑定a的地址）
    auto ref_closure = [&a]() { std::cout << "ref: " << a << " "; };
    
    a = 20; // 修改外部变量
    
    val_closure(); // 输出 "val: 10 "（使用创建时的副本）
    ref_closure(); // 输出 "ref: 20 "（跟随外部变量变化）
    return 0;
}

2. 闭包是独立的“状态载体”

每个 lambda 表达式都会生成一个唯一的闭包对象，即使代码相同，捕获的状态不同，闭包也会被视为不同的实体。

#include <iostream>

int main() {
    int x = 1, y = 2;
    
    // 两个代码逻辑相同的lambda，但捕获的状态不同
    auto closure1 = [x]() { return x; };
    auto closure2 = [y]() { return y; };
    
    std::cout << closure1() << " " << closure2() << std::endl; // 1 2
    return 0;
}

closure1 和 closure2 代码逻辑相同（return 捕获的变量），但因捕获的状态（x=1 和 y=2）不同，成为两个独立的闭包。

3. 闭包的生命周期独立于创建环境

lambda 闭包的生命周期由其自身的存储方式决定，与创建它的作用域无关。即使创建闭包的作用域已销毁，只要闭包对象仍存在，其捕获的状态就能被正常访问（值捕获安全，引用捕获需注意悬空风险）。

#include <iostream>
#include <function>

// 返回一个闭包
std::function<void()> create_closure() {
    int temp = 100; // 局部变量，作用域在create_closure内
    // 按值捕获temp：闭包存储副本，temp销毁后不影响
    return [temp]() { std::cout << "temp: " << temp << std::endl; };
}

int main() {
    auto closure = create_closure(); // create_closure已执行完毕，temp销毁
    closure(); // 正常输出 "temp: 100"（闭包持有副本）
    return 0;
}

若将上述代码改为引用捕获（[&temp]），则 closure 调用时会访问已销毁的 temp，导致未定义行为（悬空引用）——这是使用闭包时需特别注意的风险。

C++ 闭包的实现本质

C++ 编译器会将 lambda 表达式转换为一个匿名类（称为“闭包类型”，closure type），该类的行为类似仿函数（functor）：

类中包含与捕获变量对应的成员变量（值捕获为副本，引用捕获为引用）。
类重载 operator()，其实现对应 lambda 的函数体（使用成员变量访问捕获的状态）。

例如，对于 lambda [base](int x) { return base + x; }，编译器会生成类似以下的匿名类：

// 编译器生成的闭包类型（伪代码）
class __anonymous_closure {
private:
    int base; // 存储值捕获的base
public:
    // 构造函数：初始化捕获的变量
    __anonymous_closure(int b) : base(b) {}
    
    // 重载operator()：对应lambda的函数体
    int operator()(int x) const {
        return base + x;
    }
};