C++ Lambda 表达式详解：语法、捕获与底层原理

常见形式汇总

为了让你更直观地理解，这里整理了一些常见的 Lambda 定义形式。你可以把它们当作一个参考库，遇到类似场景时直接套用。

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <memory>
using namespace std;

class MyClass {
private:
    int m_num = 100;
public:
    void test_class_lambda();
};

function<int(int)> return_lambda();

int main() {
    // 1. 基础 Lambda：无捕获、无参数、无返回值
    auto basic_lambda = []() {
        cout << "[基础 Lambda] 无捕获、无参数、无返回值" << endl;
    };
    basic_lambda();

    // 2. 带参数的 Lambda（显式参数类型）
    auto param_lambda = [](int a, int b) {
        cout << "[带参数 Lambda] a + b = " << a + b << endl;
    };
    param_lambda(10, 20);

    // 3. 显式指定返回值的 Lambda
    // C++11 多分支返回值推导失败时必须用，也可提升可读性
    auto return_type_lambda = [](int a, int b) -> double {
        if (b == 0) return 0.0;
        return static_cast<double>(a) / b;
    };
    cout << "[显式返回值 Lambda] 5/2 = " << return_type_lambda(5, 2) << endl;

    // 4. 值捕获外部变量的 Lambda
    // 特点：拷贝外部变量到 Lambda 内部，默认不可修改
    int val1 = 10;
    auto value_capture_lambda = [val1]() {
        // val1 = 20; // 错误：值捕获默认不可修改
        cout << "[值捕获 Lambda] 捕获的 val1 = " << val1 << endl;
    };
    value_capture_lambda();

    // 5. mutable 修饰的值捕获 Lambda
    // 特点：允许修改值捕获的变量（仅修改内部拷贝，不影响外部）
    auto mutable_capture_lambda = [val1]() mutable {
        val1 = 20; // mutable 允许修改内部拷贝
        cout << "[mutable 值捕获 Lambda] 内部修改后的 val1 = " << val1 << endl;
    };
    mutable_capture_lambda();
    cout << "[mutable 值捕获 Lambda] 外部 val1 仍为 = " << val1 << endl; // 仍为 10

    // 6. 引用捕获外部变量的 Lambda
    // 特点：引用外部变量，修改会影响外部
    int val2 = 30;
    auto ref_capture_lambda = [&val2]() {
        val2 = 40; // 引用捕获可直接修改外部变量
        cout << "[引用捕获 Lambda] 修改后的 val2 = " << val2 << endl;
    };
    ref_capture_lambda();
    cout << "[引用捕获 Lambda] 外部 val2 同步修改为 = " << val2 << endl; // 变为 40

    // 7. 隐式捕获 Lambda
    // 7.1 隐式值捕获（=）：捕获所有外部变量（值拷贝）
    int a = 5, b = 6;
    auto implicit_val_capture = [=]() {
        cout << "[隐式值捕获] a = " << a << ", b = " << b << endl;
    };
    implicit_val_capture();

    // 7.2 隐式引用捕获（&）：捕获所有外部变量（引用）
    auto implicit_ref_capture = [&]() {
        a = 50; b = 60;
        cout << "[隐式引用捕获] 修改后 a = " << a << ", b = " << b << endl;
    };
    implicit_ref_capture();

    // 8. 混合捕获 Lambda
    // 特点：默认捕获 + 指定捕获（优先级更高）
    int x = 100, y = 200;
    auto mix_capture_lambda = [=, &x]() {
        // 默认值捕获，仅 x 引用捕获
        x = 1000; // 引用捕获可修改
        // y = 2000; // 错误：y 是值捕获，不可修改（需加 mutable）
        cout << "[混合捕获 Lambda] x = " << x << ", y = " << y << endl;
    };
    mix_capture_lambda();

    // 9. 泛型 Lambda（C++14+）
    // 特点：参数用 auto，支持任意类型参数（类似模板函数）
    auto generic_lambda = [](auto val1, auto val2) {
        cout << "[泛型 Lambda] val1 = " << val1 << ", val2 = " << val2 << endl;
    };
    generic_lambda(123, 3.14); // int + double
    generic_lambda("hello", string("cpp")); // const char* + string

    // 10. 立即调用的匿名 Lambda
    // 特点：定义后立即执行，无需赋值给变量，一次性使用
    cout << "[立即调用 Lambda] 执行结果：";
    []() {
        cout << "匿名 Lambda 立即执行" << endl;
    }();

    // 11. 移动捕获 Lambda（C++14+）
    // 特点：捕获仅可移动的对象（如 unique_ptr），转移所有权
    unique_ptr<int> ptr = make_unique<int>(500);
    auto move_capture_lambda = [p = move(ptr)]() {
        cout << "[移动捕获 Lambda] 捕获的 unique_ptr 值 = " << *p << endl;
    };
    move_capture_lambda();
    // ptr 已为空（所有权转移）
    if (!ptr) cout << "[移动捕获 Lambda] 外部 ptr 已空" << endl;

    // 12. 作为 STL 算法参数的 Lambda
    // 特点：就地定义回调逻辑，无需单独定义普通函数
    vector<int> vec = {5, 2, 9, 1, 5, 6};
    sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b; // 降序排序规则
    });
    cout << "[STL 算法 Lambda] 降序排序结果：";
    for (int n : vec) cout << n << " ";
    cout << endl;

    // 13. 类内捕获 this 的 Lambda
    // 特点：访问类的成员变量/函数，无需传 this 指针
    MyClass obj;
    obj.test_class_lambda();

    // 14. 作为函数返回值的 Lambda
    // 特点：需用 std::function 包装，可返回带捕获的 Lambda
    auto returned_lambda = return_lambda();
    cout << "[返回 Lambda] 调用结果：" << returned_lambda(5) << endl;

    return 0;
}

// 类内 Lambda 实现
void MyClass::test_class_lambda() {
    auto class_lambda = [this]() {
        m_num = 200; // 捕获 this，访问类成员变量
        cout << "[类内 Lambda] 修改后的 m_num = " << m_num << endl;
    };
    class_lambda();
}

// 返回 Lambda 的函数实现
function<int(int)> return_lambda() {
    int base = 10;
    // 返回带值捕获的 Lambda，用 std::function 包装
    return [base](int x) {
        return x + base;
    };
}

核心：捕获子句

捕获子句是 Lambda 最关键的部分，决定了 Lambda 能访问哪些外部变量，以及以何种方式访问（值/引用）。

捕获方式分类

捕获示例详解

1. 值捕获 vs 引用捕获

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 20;

    // 1. 值捕获：拷贝 a、b 到 Lambda 内部
    auto lambda_val = [a, b]() {
        // a = 100; // 错误！值捕获的变量默认不可修改（需加 mutable）
        cout << "值捕获：a=" << a << ", b=" << b << endl; // 输出：10,20
    };
    lambda_val();

    // 2. 引用捕获：引用 a、b（修改会影响外部）
    auto lambda_ref = [&a, &b]() {
        a = 100; b = 200;
        cout << "引用捕获修改后：a=" << a << ", b=" << b << endl; // 输出：100,200
    };
    lambda_ref();
    cout << "外部变量：a=" << a << ", b=" << b << endl; // 输出：100,200（外部被修改）

    // 3. mutable：允许修改值捕获的变量（仅修改 Lambda 内部拷贝，不影响外部）
    auto lambda_mutable = [a]() mutable {
        a = 999;
        cout << "mutable 值捕获：a=" << a << endl; // 输出：999
    };
    lambda_mutable();
    cout << "外部 a：" << a << endl; // 输出：100（外部未变）

    return 0;
}

2. 隐式捕获

#include <iostream>
using namespace std;

int main() {
    int x = 5, y = 6;

    // 隐式值捕获：捕获所有外部变量（x、y），值拷贝
    auto lambda_implicit_val = [=]() {
        cout << "隐式值捕获：x=" << x << ", y=" << y << endl; // 输出：5,6
    };
    lambda_implicit_val();

    // 隐式引用捕获：捕获所有外部变量（x、y），引用
    auto lambda_implicit_ref = [&]() {
        x = 50; y = 60;
        cout << "隐式引用捕获：x=" << x << ", y=" << y << endl; // 输出：50,60
    };
    lambda_implicit_ref();

    // 混合捕获：默认值捕获，仅 x 用引用
    auto lambda_mix = [=, &x]() {
        x = 500; // 引用捕获，可修改且影响外部
        // y = 600; // 错误！y 是值捕获，不可修改（需加 mutable）
        cout << "混合捕获：x=" << x << ", y=" << y << endl; // 输出：500,60
    };
    lambda_mix();

    return 0;
}

3. 类内捕获 this

Lambda 在类的成员函数中可以捕获 this 指针，从而访问类的成员变量/函数：

#include <iostream>
using namespace std;

class MyClass {
private:
    int num = 100;
public:
    void func() {
        // 捕获 this，访问类成员
        auto lambda = [this]() {
            num = 200; // 修改成员变量
            cout << "类内 Lambda：num=" << num << endl; // 输出：200
        };
        lambda();
    }
    int get_num() { return num; }
};

int main() {
    MyClass obj;
    obj.func();
    cout << "外部访问：" << obj.get_num() << endl; // 输出：200
    return 0;
}

Lambda 的进阶特性

1. 自动推导返回值（省略 -> return_type）

C++11 起，若 Lambda 函数体只有 return 语句，编译器可自动推导返回值；C++14 后支持任意函数体的返回值推导：

#include <iostream>
using namespace std;

int main() {
    // C++11 支持：单 return 语句自动推导
    auto add = [](int a, int b) { return a + b; }; // 自动推导返回值为 int
    cout << add(3, 5) << endl; // 输出：8

    // C++14 支持：多分支自动推导（需返回值类型一致）
    auto calc = [](int a, int b, char op) {
        if (op == '+') return a + b;
        else return a - b;
    };
    cout << calc(10, 3, '-') << endl; // 输出：7

    return 0;
}

2. C++11 多分支返回值推导失败

C++11 对 Lambda 返回值自动推导的限制：仅当函数体只有单个 return 语句时能推导，多分支会报错，此时必须用 -> 显式声明返回值类型。

#include <iostream>
using namespace std;

int main() {
    // 正确示例：显式指定返回值类型为 double
    auto calc = [](int a, int b, char op) -> double {
        if (op == '+') return a + b; // int 自动转为 double
        else return 0.0; // 原生 double
    };
    cout << calc(10, 20, '+') << endl; // 输出 30.0（double 类型）
    cout << calc(10, 20, '-') << endl; // 输出 0.0（double 类型）
    return 0;
}

3. 泛型 Lambda（C++14）

参数列表中使用 auto，让 Lambda 支持任意类型的参数（类似模板函数）：

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

int main() {
    // 泛型 Lambda：支持任意类型的参数
    auto print = [](auto val) {
        cout << "泛型 Lambda：" << val << endl;
    };
    print(123);       // 输出：123（int）
    print(3.14);      // 输出：3.14（double）
    print("hello");   // 输出：hello（const char*）
    print(string("cpp")); // 输出：cpp（string）
    return 0;
}

4. Lambda 作为函数参数/返回值

Lambda 可作为 STL 算法的参数（最常用场景），也可作为函数返回值（需用 std::function）：

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

// Lambda 作为函数参数（用 std::function 接收）
void process_data(int a, int b, function<int(int, int)> func) {
    cout << "处理结果：" << func(a, b) << endl;
}

// Lambda 作为返回值
function<int(int)> get_lambda() {
    int base = 10;
    // 返回一个 Lambda（捕获 base）
    return [base](int x) { return x + base; };
}

int main() {
    // 1. Lambda 作为 STL 算法参数（排序）
    vector<int> vec = {5, 2, 9, 1, 5, 6};
    // 自定义排序规则：降序
    sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });
    cout << "降序排序：";
    for (int n : vec) cout << n << " "; // 输出：9 6 5 5 2 1
    cout << endl;

    // 2. Lambda 作为函数参数
    process_data(10, 20, [](int a, int b) { return a * b; }); // 输出：200

    // 3. Lambda 作为返回值
    auto func = get_lambda();
    cout << "返回 Lambda 调用：" << func(5) << endl; // 输出：15（5+10）
    return 0;
}

5. 捕获表达式（C++14）：移动语义捕获

可以用 std::move 捕获仅可移动的变量（如 std::unique_ptr）：

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

int main() {
    unique_ptr<int> ptr = make_unique<int>(100);
    // 移动捕获：将 ptr 的所有权转移到 Lambda 内部
    auto lambda = [p = move(ptr)]() {
        cout << "移动捕获：" << *p << endl; // 输出：100
    };
    lambda();
    // ptr 已为空（所有权转移）
    if (!ptr) cout << "外部 ptr 已空" << endl;
    return 0;
}

Lambda 的本质（底层逻辑）

Lambda 并非'魔法'，编译器会将 Lambda 转换为匿名的函数对象（仿函数）：

• 捕获子句对应函数对象的成员变量（值捕获 = 拷贝构造，引用捕获 = 引用成员）；
• Lambda 的参数/函数体对应函数对象的 operator() 重载；
• mutable 对应 operator() 重载为非 const（值捕获的成员变量默认是 const，需 mutable 解除）。

比如以下 Lambda：

int a = 10;
auto lambda = [a]() mutable { a++; };

编译器会生成类似这样的代码（伪代码）：

// 编译器生成的匿名类（伪代码）
class __lambda_12345 {
private:
    int a; // 值捕获的变量
public:
    __lambda_12345(int a_) : a(a_) {}
    void operator()() { // mutable 对应非 const
        a++;
    }
};

// 实际调用
__lambda_12345 lambda(10);
lambda();

Lambda 的使用注意事项

1. 值捕获是拷贝：值捕获的变量是 Lambda 创建时的拷贝，而非实时值；
2. this 捕获的风险：若 Lambda 的生命周期超过对象生命周期，this 会悬空；
3. Lambda 不能被重载：Lambda 是匿名的，无法像普通函数一样重载。

引用捕获的生命周期：若 Lambda 的生命周期超过被引用变量的生命周期，会导致悬空引用（访问已释放的内存）：

// 错误示例：返回引用捕获局部变量的 Lambda
auto bad_lambda() {
    int x = 10;
    return [&x]() { cout << x << endl; }; // x 已销毁，调用时未定义行为
}

Lambda 对比 普通函数

场景 1：访问外部变量（Lambda 最核心的优势）

普通函数要访问当前作用域的变量，只有两种方式：传参（麻烦）或全局变量（危险，易污染）；而 Lambda 可以通过「捕获子句」直接访问，无需额外操作。

普通函数实现（麻烦/不优雅）

#include <iostream>
using namespace std;

// 普通函数：要访问外部的 factor，必须传参
int multiply(int num, int factor) {
    return num * factor;
}

int main() {
    int factor = 5; // 局部变量
    // 调用普通函数：必须手动传 factor
    cout << multiply(10, factor) << endl; // 输出 50
    cout << multiply(20, factor) << endl; // 输出 100
    return 0;
}

Lambda 实现（简洁）

#include <iostream>
using namespace std;

int main() {
    int factor = 5; // 局部变量
    // Lambda：直接捕获 factor，无需传参
    auto multiply = [factor](int num) { return num * factor; };
    // 调用时只需传 num，factor 已被捕获
    cout << multiply(10) << endl; // 输出 50
    cout << multiply(20) << endl; // 输出 100
    return 0;
}

场景 2：STL 算法回调（就地定义，代码不割裂）

普通函数作为 STL 算法的回调时，需要单独定义（代码跳来跳去）；Lambda 可以「就地定义」，逻辑和调用位置在一起，可读性大幅提升。

普通函数实现（代码割裂）

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

// 普通函数：排序规则（降序），需单独定义
bool compare(int a, int b) {
    return a > b;
}

int main() {
    vector<int> vec = {5, 2, 9, 1, 5, 6};
    // 调用 sort，传入普通函数名
    sort(vec.begin(), vec.end(), compare);
    for (int n : vec) cout << n << " "; // 9 6 5 5 2 1
    return 0;
}

Lambda 实现（就地定义，代码连贯）

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

int main() {
    vector<int> vec = {5, 2, 9, 1, 5, 6};
    // Lambda：排序规则直接写在 sort 参数里，无需跳转到其他位置
    sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });
    for (int n : vec) cout << n << " "; // 9 6 5 5 2 1
    return 0;
}

场景 3：一次性小逻辑（避免命名污染）

对于只使用一次的小逻辑，普通函数需要起名字（哪怕只用一次），容易造成'命名污染'；Lambda 匿名使用，用完即丢，无需命名。

普通函数实现（命名污染）

#include <iostream>
using namespace std;

// 只用一次的小函数，却要起名字（比如叫 print_welcome）
void print_welcome() {
    cout << "欢迎使用本程序！" << endl;
}

int main() {
    // 仅调用一次
    print_welcome(); // 后续再也不用这个函数，但它的名字仍占用命名空间
    return 0;
}

Lambda 实现（匿名，无命名污染）

#include <iostream>
using namespace std;

int main() {
    // 匿名 Lambda：直接定义 + 调用，无需命名，用完即销毁
    []() {
        cout << "欢迎使用本程序！" << endl;
    }(); // 最后的 () 表示立即调用
    return 0;
}

场景 4：类内访问成员（Lambda 捕获 this 更便捷）

普通函数要访问类的成员变量，需要传 this 指针或对象；Lambda 可以直接捕获 this，一键访问类成员。

普通函数实现（麻烦）

#include <iostream>
using namespace std;

class MyClass {
private:
    int base = 100;
public:
    // 普通函数：需传 this 指针才能访问 base
    static int add(MyClass* obj, int num) {
        return obj->base + num;
    }
    void func() {
        // 调用普通函数，必须传 this
        cout << add(this, 50) << endl; // 输出 150
    }
};

int main() {
    MyClass obj;
    obj.func();
    return 0;
}

Lambda 实现（简洁）

#include <iostream>
using namespace std;

class MyClass {
private:
    int base = 100;
public:
    void func() {
        // Lambda：捕获 this，直接访问 base
        auto add = [this](int num) { return this->base + num; };
        cout << add(50) << endl; // 输出 150
    }
};

int main() {
    MyClass obj;
    obj.func();
    return 0;
}