lambda表达式基础

代码仓库shanchuann/CPP-Learninng，进阶内容参见分类: 现代 C++之旅 | lambda 表达式

Lambda 表达式是 C++11 中引入的常用特性，这类特性最早在 C#3.5 中落地， Java 则是在 8 版本中才加入对应支持。该特性源自函数式编程理念，也是现代编程语言的常见设计方向，主要为解决传统临时函数对象编写繁琐、代码分散的问题而生。

Lambda 表达式具备多项实用优势，采用声明式编程风格，可就地匿名定义目标函数或函数对象，无需额外编写独立的命名函数或函数对象，能以更直接的方式编写程序，兼顾可读性与可维护性。同时写法足够简洁，避免了代码膨胀和功能分散，让开发者更聚焦当前逻辑，也能提升开发效率。此外，它还能在合适的场景实现功能闭包，让程序整体更具灵活性。

基础语法

Lambda 表达式本质是匿名函数，同时可通过指定规则捕获一定范围内的外部变量，完整语法形式可归纳为：[capture](params) opt->ret{body;};。其中各部分含义清晰， capture 为捕获列表，用于控制外部变量的访问规则； params 是参数列表，承接函数传入的参数； opt 为函数可选修饰符； ret 代表返回值类型； body 则是具体的函数执行体。

用法与返回值

C++11 中 Lambda 表达式采用返回值后置语法，多数场景下编译器可根据 return 语句自动推导返回值类型，无需手动声明；仅特殊场景需要显式指定返回值。同时无参数的 Lambda 表达式，可直接省略参数列表。

// 完整语法写法，显式声明返回值
auto f = [](int a) -> int { return a + 1; };
// 调用Lambda表达式，输出结果2
std::cout << f(1) << std::endl;

// 省略返回值声明，编译器自动推导
auto f1 = [](int a) { return a + 1; };
// 省略空参数列表，合法写法
auto f2 = [] { return 1; };

第一行通过完整语法定义了接收整型参数并返回参数加 1 的匿名函数；第二行调用该函数，传入参数 1 得到结果 2 。后续示例分别展示了省略返回值声明、省略空参数列表的简化写法，均符合 C++11 语法规范。

需要注意，初始化列表无法参与返回值自动推导，多分支返回不同类型的场景也无法完成自动推导，此类场景必须显式声明返回值类型，否则会触发编译错误。

// 合法，编译器可推导返回值为int
auto x1 = [](int i) { return i; };
// 非法，初始化列表无法推导返回值，需显式声明
auto x2 = [] { return {1,2}; };

捕获列表

捕获列表是 Lambda 表达式的重要组成部分，用于精细控制外部变量的访问权限与传递方式，仅能捕获当前作用域内的自动局部变量，全局变量、静态局部变量无需捕获即可直接使用， PDF 中梳理了多种标准捕获形式，搭配对应代码示例可清晰理解差异。

基础捕获类型

• 空捕获：[]，不捕获任何外部变量， Lambda 体内无法使用所在函数的自动局部变量，全局与静态变量可直接调用。
• 隐式引用捕获：[&]，隐式捕获外部作用域所有用到的自动变量，在体内以引用形式使用，修改会同步到外部原变量。
• 隐式值捕获：[=]，隐式捕获外部作用域所有用到的自动变量，在体内以副本形式使用，修改不会影响外部原变量。
• 混合捕获：[=,&foo]表示按值隐式捕获所有变量，仅按引用显式捕获 foo ；[&,foo]表示按引用隐式捕获所有变量，仅按值显式捕获 foo ；也可手动指定单个变量捕获，不涉及其余变量。
• this 指针捕获：[this]，捕获当前类的 this 指针，可在 Lambda 体内访问类的成员函数与成员变量，若已用&或=，会默认包含 this 捕获。
• 静态变量特殊说明：全局变量、函数内静态局部变量不属于捕获范畴，可直接在 Lambda 体内调用，无需写入捕获列表。

值捕获

值捕获的前提是变量可拷贝，与传值参数不同，值捕获的变量在 Lambda 创建时就完成拷贝，而非调用时拷贝，外部后续修改原变量不会影响 Lambda 内的副本。

#include <iostream>
using namespace std;
// 自定义Int类，用于直观观察拷贝行为
class Int {
private:
    int value;
public:
    Int(int x = 0) : value(x) {}
    Int operator+(const Int &it) const { return Int(this->value + it.value); }
    int Getvalue() const { return value; }
};
// 重载输出符，方便打印结果
ostream & operator<<(ostream &out, const Int &it) {
    return out << it.Getvalue();
}

int main() {
    Int c = 6872;
    Int d = 5032;
    // 值捕获c和d，创建时拷贝副本
    auto Add = [c, d](Int a, Int b) -> Int {
        cout << "c=" << c << endl << "d=" << d << endl;
        return a + b;
    };
    // 修改外部原变量d
    d = 20;
    // 调用Lambda，内部c、d仍为创建时的拷贝值
    std::cout << "1+2=" << Add(1, 2) << std::endl;
    return 0;
}

代码中先定义自定义 Int 类，便于观察变量拷贝逻辑；主函数中初始化变量 c 、 d 后，通过值捕获定义 Lambda 表达式 Add ，随后修改外部变量 d ，调用 Add 时，体内打印的 c 、 d 依旧是初始值，充分体现值捕获“创建时拷贝”的特性。

捕获变量的常性

Lambda 表达式的捕获变量自带常性约束，这一特性源于 Lambda 底层闭包类型的设计规则，也是使用过程中需要重点留意的细节。 Lambda 闭包类型重载的operator()默认带有 const 限定，这一限定会直接作用于值捕获的变量，使其具备只读属性，无法在 Lambda 体内直接修改。

值捕获的变量会作为闭包类的成员变量存储，受默认 const 属性约束，即便外部变量本身可修改， Lambda 体内的副本也无法直接赋值、修改，只能读取使用，这也是常规值捕获无法修改变量的核心原因。而引用捕获的变量， const 限定仅约束引用本身无法更改指向，不会限制引用指向对象的修改操作，因此引用捕获的变量可直接在体内修改，不受常性约束影响。

想要解除值捕获变量的常性、允许修改副本，需要在 Lambda 参数列表后添加mutable关键字， mutable 的作用就是取消operator()的默认 const 限定，让值捕获的成员变量恢复可修改状态，这也是可变 Lambda 的核心实现逻辑。

#include <iostream>
using namespace std;

int main() {
    int num = 10;

    // 1. 默认值捕获：受常性约束，修改变量会触发编译报错
    // 错误示例：试图修改值捕获的num副本，const限定不允许
    auto err_func = [num] {
        // num += 5;  放开注释会编译失败，值捕获变量只读
        cout << "值捕获只读num：" << num << endl;
    };
    err_func();

    // 2. mutable修饰：解除常性，允许修改值捕获副本
    auto mutable_func = [num] mutable {
        num += 5;  // 合法，mutable取消了operator()的const限定
        cout << "mutable修改后副本num：" << num << endl;
    };
    mutable_func();
    // 外部原变量不变，仅副本被修改
    cout << "外部原变量num：" << num << endl;

    // 3. 引用捕获：不受常性约束，可直接修改外部变量
    auto ref_func = [&num] {
        num += 5;  // 合法，引用捕获无只读限制
        cout << "引用捕获修改后num：" << num << endl;
    };
    ref_func();

    return 0;
}

第一组默认值捕获示例中，试图修改变量会直接编译失败，直观体现值捕获的只读常性；第二组添加 mutable 后，成功解除 const 限定，可修改变量副本，且不影响外部原变量；第三组引用捕获示例，全程无修改限制，直接改动外部变量，完整印证三类捕获的常性差异。

引用捕获

引用捕获保存的是外部变量的引用， Lambda 体内对变量的修改会直接同步到外部原变量，无需额外修饰即可完成修改操作。

int main() {
    Int c = 6872;
    Int d = 5032;
    // 引用捕获c和d，直接操作外部变量
    auto Add = [&c, &d](Int a, Int b) -> Int {
        c = 68725032;
        d = c;
        return a + b;
    };
    cout << "1+2=" << Add(1, 2) << endl;
    // 外部打印c、d，值已被Lambda修改
    cout << "c=" << c << endl;
    cout << "d=" << d << endl;
    return 0;
}

采用引用捕获后， Lambda 体内修改 c 、 d 的操作，会直接改变外部主函数中对应变量的数值，后续外部打印结果可验证修改生效，这是引用捕获与值捕获的核心区别。

this 指针捕获

this 指针捕获是类成员函数中使用 Lambda 的关键捕获形式，属于 PDF 明确标注的核心捕获规则，前文基础捕获仅做简要罗列，此处展开完整使用细则与底层逻辑。 this 捕获用于获取当前类实例的指针，让 Lambda 体内获得和类成员函数一致的成员访问权限，是类内封装短小逻辑的常用方式。

this 捕获的使用规则清晰且固定，其一，捕获格式分为显式与隐式，[this]为显式捕获当前实例指针，[=]与[&]两种隐式捕获，会默认自动包含 this 捕获，无需额外添加；其二，访问范围受限，仅能直接访问类的成员变量与成员函数，无法直接使用所属成员函数的形参、局部自动变量，这类变量需单独写入捕获列表显式声明；其三，遵循默认常性约束，通过 this 指针访问的成员变量，受 Lambda 闭包 const 限定影响，默认只读，修改成员变量需搭配 mutable 解除常性，或改用引用捕获。

C++17 新增的[*this]拷贝捕获规则，该形式会拷贝当前类实例， Lambda 内操作的是实例副本，不会修改外部原实例，和传统[this]指针捕获的共享实例形成区分，适配需要隔离实例状态的场景，完整覆盖 PDF 提及的标准迭代细节。

#include <iostream>
using namespace std;

class TestClass {
private:
    int m_val;
public:
    TestClass(int val) : m_val(val) {}

    // 类成员函数内的this捕获演示
    void testThisCapture() {
        int local_param = 20;

        // 1. 显式this捕获：仅访问类成员，无法直接用local_param
        auto func1 = [this]() {
            // 可直接访问成员变量m_val，遵循常性，默认只读
            cout << "显式this捕获，成员变量值：" << m_val << endl;
        };
        func1();

        // 2. 隐式值捕获[=]：自动包含this，且可捕获局部变量local_param
        auto func2 = [=]() {
            cout &lt;&lt; "隐式[=]捕获，成员变量：" &lt;&lt; m_val << endl;
            cout << "隐式[=]捕获，局部变量：" << local_param << endl;
        };
        func2();

        // 3. mutable解除常性，修改成员变量
        auto func3 = [this]() mutable {
            // 取消const限定，可修改成员变量
            m_val += 10;
            cout << "mutable修改后成员变量：" << m_val << endl;
        };
        func3();

        // 4. C++17 [*this]拷贝捕获，修改副本不影响原实例
        auto func4 = [*this]() {
            // 修改的是实例副本，原实例m_val不变
            m_val += 50;
            cout << "拷贝捕获修改副本：" << m_val << endl;
        };
        func4();
        // 外部原实例成员变量仅被func3修改，不受func4影响
        cout << "最终原实例成员变量：" << m_val << endl;
    }
};

int main() {
    TestClass obj(100);
    obj.testThisCapture();
    return 0;
}

这段代码完整演示了 this 捕获的各类场景，显式 this 捕获仅能访问类成员；隐式[=]自动携带 this ，同时可捕获局部变量； mutable 可解除成员变量的只读常性； C++17 的[*this]拷贝捕获实现实例隔离，完整贴合 PDF 中 this 捕获的全部规则与版本迭代细节。

新增特性

Lambda 表达式在后续 C++标准中持续优化，各版本新增特性均有明确规范，完整覆盖 PDF 提及的标准迭代内容：

C++14

C++11 的基础捕获仅支持左值捕获， C++14 新增两项关键能力，一是表达式捕获，支持捕获右值，可通过任意表达式初始化捕获变量，变量类型由编译器自动推导，兼容移动语义；二是泛型 Lambda ，允许形参使用 auto 关键字，摆脱固定类型限制，适配多类型参数传入。

C++17 与 C++20

C++17 新增 constexpr Lambda ，支持在编译期执行 Lambda 逻辑，适配常量表达式场景； C++20 进一步支持模板 Lambda ，可通过模板参数实现更灵活的泛型约束，完善不同场景的使用需求，完整贴合现代 C++标准迭代路径。

表达式捕获

C++11 的基础捕获仅支持左值捕获， C++14 新增表达式捕获，支持捕获右值，可通过任意表达式初始化捕获变量，变量类型由编译器自动推导，兼容移动语义。

#include <iostream>
#include <memory>
using namespace std;

int main() {
    // 生成独占指针，属于右值
    auto important = make_unique<Int>(1);
    // 表达式捕获，移动语义捕获右值，普通变量直接初始化
    auto add = [v1 = 1, v2 = move(important)](Int x, Int y) -> Int {
        return x + y + v1 + (*v2);
    };
    cout << add(3,4) << endl;
    return 0;
}

泛型 Lambda

C++11 中 Lambda 形参需指定具体类型， C++14 允许形参使用 auto 关键字，实现泛型效果，适配不同类型的参数传入。

int main() {
    // 泛型Lambda，自动适配int、double等类型
    auto add = [](auto x, auto y) {
        return x + y;
    };
    // 传入整型参数
    std::cout << add(1, 2) << std::endl;
    // 传入浮点型参数
    std::cout << add(1.1, 1.2) << std::endl;
    return 0;
}

可变 Lambda

默认情况下，值捕获的变量在 Lambda 体内无法修改，若需修改值捕获的副本，需添加 mutable 修饰；被 mutable 修饰的 Lambda ，无论是否包含参数，都必须保留参数列表()，这是语法强制要求。引用捕获的变量可直接修改，无需 mutable 修饰，且不受该约束限制。

void test12() {
    int v = 5;
    // mutable修饰，可修改值捕获的副本
    auto ff = [v] mutable { return ++v; };
    // 外部修改原变量v
    v = 0;
    // 调用Lambda，返回修改后的副本值6
    auto j = ff();
}

void test13() {
    int v = 5;
    // 引用捕获，直接修改外部变量，无需mutable
    auto ff = [&v] { return ++v; };
    v = 0;
    // 调用Lambda，返回修改后的外部变量值1
    auto j = ff();
}

类成员函数中的 Lambda

在类的成员函数内使用 Lambda ，全局变量无需捕获即可直接使用；不同捕获方式，对成员变量、函数形参的访问权限不同，可通过以下示例清晰区分。

int g_max = 10;
class Object {
    int value;
public:
    Object(int x = 0) : value(x) {}
    void func(int a, int b) {
        // 合法，全局变量无需捕获
        auto x0 = []() -> int { return g_max; };
        // 非法，空捕获无法访问形参a
        auto x1 = []() -> int { return a; };

        // [=]值捕获所有外部变量（形参、局部变量、this指针）
        auto x2 = [=]() -> int {
            int x = value;
            return x + a + g_max;
        };

        // [&]引用捕获所有外部变量，可直接修改成员变量
        auto x3 = [&]() -> int {
            g_max = 100;
            value += 10;
            return g_max + value;
        };

        // [this]仅捕获this指针，可访问成员变量，无法直接用形参a、b
        auto x4 = [this](int c) -> int {
            value += 100;
            return value + c;
        };

        // 合法，显式捕获this、a、b，可正常使用
        auto x6 = [this, a, b]() { value = a + b; };
    }
};

类内使用 Lambda 时，全局变量可直接访问；[=]和[&]可同时捕获形参、局部变量与 this 指针；[this]仅能访问类成员，需额外显式捕获函数形参才能使用，这是类内 Lambda 的关键使用规则。

Lambda 类型与存储方式

C++11 中， Lambda 表达式的类型被称作闭包类型，属于特殊的匿名非联合体类类型，本质是重载了operator()的仿函数，且每个 Lambda 对应独一无二的闭包类型，不同 Lambda 之间无法互相赋值。基于这一特性，可通过 std::function 和 std::bind 存储、操作 Lambda 表达式；无任何变量捕获的 Lambda ，还可隐式转换为普通函数指针，带有捕获的 Lambda 则无法完成该转换。

#include <functional>
using namespace std;

int main() {
    int x = 0;
    // std::function存储Lambda
    std::function<int(int)> f1 = [](int a) { return a; };
    x = f1(10); // x结果为10

    // std::bind绑定Lambda
    std::function<int(void)> f2 = bind([](int a) { return a; }, 123);
    x = f2(); // x结果为123

    // 无捕获Lambda转换为函数指针，合法
    using func_t = int(*)(int);
    func_t f = [](int a) -> int { return a; };
    // 有捕获Lambda转换为函数指针，非法
    // func_t f_err = [&x](int a) { return a + x; };
    return 0;
}

补充说明： Lambda 的operator()默认是 const 属性，因此值捕获的变量无法直接修改， mutable 修饰的作用就是取消该 const 属性，允许修改值捕获的副本。

使用细节与易错点

延迟调用问题

值捕获的 Lambda 存在延迟调用差异，变量在定义时就完成拷贝，后续外部修改原变量，不会影响 Lambda 内的副本；若需调用时实时获取外部变量最新值，需使用引用捕获。同时需注意引用捕获的悬空风险，必须保证被引用变量的生命周期覆盖 Lambda 整个调用周期，避免变量提前销毁导致未定义行为。此外， Lambda 无法捕获超出当前作用域的块级自动变量，也不能捕获其他函数的局部变量，否则会触发编译错误。

int main() {
    int a = 0;
    // 值捕获，定义时拷贝a的副本为0
    auto funa = [=] { return a; };
    // 外部修改a
    a += 100;
    // 调用Lambda，依旧返回0，而非100
    cout << funa() << endl;
    return 0;
}

实际应用场景

Lambda 表达式可简化标准库算法的调用，替代传统仿函数，让代码更紧凑，逻辑更直观，无需单独定义仿函数类，就地编写处理逻辑即可。

配合 STL 算法

#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> v = {1,2,3,4,5,6};
    int even_count = 0;
    // 配合for_each统计偶数个数，引用捕获计数变量
    for_each(v.begin(), v.end(), [&even_count](int val) {
        if (!(val & 1)) {
            ++even_count;
        }
    });
    cout << "偶数个数：" << even_count << endl;

    // 配合count_if统计5-10之间的元素个数
    int count = count_if(v.begin(), v.end(), [](int x) {
        return x > 5 && x < 10;
    });
    cout << "5-10之间元素个数：" << count << endl;
    return 0;
}

Lambda 与传统仿函数对比

Lambda 可看作就地定义仿函数的语法糖，功能上可替代绝大多数手动编写的仿函数，大幅减少代码量，逻辑更集中，以下是仿函数与 Lambda 实现相同功能的对比。

// 传统仿函数写法
class CountEven {
    int& count_;
public:
    CountEven(int& count) : count_(count) {}
    void operator()(int val) const {
        if (val % 2 == 0) ++count_;
    }
};

void funa() {
    vector<int> ar = {1,2,3,4,5,6,7,8};
    int even_count = 0;
    // 调用仿函数
    for_each(ar.begin(), ar.end(), CountEven(even_count));
    cout << "偶数个数：" << even_count << endl;
}

// Lambda写法，更简洁
void funb() {
    vector<int> ar = {1,2,3,4,5,6,7,8};
    int even_count = 0;
    for_each(ar.begin(), ar.end(), [&even_count](int val) {
        if (val % 2 == 0) ++even_count;
    });
    cout << "偶数个数：" << even_count << endl;
}

整体来看， Lambda 表达式简化了匿名函数与闭包的编写流程，适配现代 C++编程习惯，从 C++11 基础落地到后续标准持续优化，覆盖了日常开发中短小逻辑封装、标准库算法配合、回调函数编写等多数场景。它可替代绝大多数手动编写的仿函数，大幅精简代码量、集中业务逻辑，虽无法完全替代 std::function （部分老旧库仅兼容 std::function ），但整体使用灵活性更高，是现代 C++开发中常用的语法特性。