认识lambda

✅ 核心先记：lambda捕获规则
 
 []  捕获区决定外部变量的使用方式， ()  参数区， {}  函数体
✅ 值传递： [x,y]  → 拷贝外部变量，lambda内只读（默认），修改需加 mutable 
✅ 引用传递： [&x,&y]  → 直接引用外部变量，lambda内修改会同步影响外部
✅ 混合捕获： [x,&y]  → 部分值传、部分引用，最常用场景
 
📌 示例1：值传递（默认只读，拷贝外部变量）
 
cpp   
#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 20;
    // 【值传递】捕获a、b，拷贝到lambda内部，默认只读
    auto lambda_val = [a, b]() {
        // a++; ❌ 报错！值传递默认不可修改外部拷贝的变量
        cout << "值传递：a=" << a << ", b=" << b << endl;
    };
    a = 100; b = 200; // 外部修改变量
    lambda_val();      // 输出：10,20 ✅ 用的是捕获时的拷贝值，不受外部修改影响
    return 0;
}
 
 
📌 示例2：值传递+mutable（可修改内部拷贝的变量）
 
cpp   
int main() {
    int a = 10;
    // 【值传递+mutable】解锁内部拷贝变量的修改权限
    auto lambda_val_mu = [a]() mutable {
        a++; // ✅ 允许修改，仅改lambda内部的拷贝值
        cout << "mutable值传递：内部a=" << a << endl;
    };
    lambda_val_mu(); // 输出：11
    cout << "外部a=" << a << endl; // 输出：10 ✅ 外部变量完全不受影响
    return 0;
}
 
 
📌 示例3：引用传递（直接绑定外部变量，修改同步）
 
cpp   
int main() {
    int a = 10, b = 20;
    // 【引用传递】&a、&b 绑定外部变量，无拷贝
    auto lambda_ref = [&a, &b]() {
        a++; b++; // ✅ 直接修改外部变量
        cout << "引用传递：a=" << a << ", b=" << b << endl;
    };
    lambda_ref();      // 输出：11,21
    cout << "外部：a=" << a << ", b=" << b << endl; // 输出：11,21 ✅ 同步修改
    return 0;
}
 
 
📌 示例4：混合捕获（最常用！部分值传+部分引用）
 
✅ 核心场景：只读的变量用值传，需要修改的变量用引用传
 
cpp   
int main() {
    int fix_val = 100;  // 固定值，无需修改 → 值传递
    int change_val = 0; // 需要修改 → 引用传递
    // 【混合捕获】fix_val值传，change_val引用传
    auto lambda_mix = [fix_val, &change_val](int add) {
        change_val += fix_val + add; // 修改引用变量，使用值传变量
        cout << "混合：fix=" << fix_val << ", change=" << change_val << endl;
    };
    lambda_mix(50); // 输出：fix=100, change=150
    cout << "外部change=" << change_val << endl; // 输出：150 ✅ 同步修改
    fix_val = 200;  // 外部修改值传变量
    lambda_mix(50); // 输出：fix=100, change=300 ✅ 值传仍用捕获时的拷贝
    return 0;
}
 
 
📌 补充2个快捷捕获语法（实战常用）
 
cpp   
int main() {
    int a=10, b=20;
    // 1. [=] 所有外部变量都值传递
    auto lambda_all_val = [=]() { cout << a << "," << b << endl; };
    // 2. [&] 所有外部变量都引用传递
    auto lambda_all_ref = [&]() { a++; b++; };
    return 0;
}
 
✅ 值传递 [x]：拷贝一份，lambda内独立，不影响外部，安全只读
✅ 值传递+mutable：仅能改内部拷贝，外部不变，适合临时修改
✅ 引用传递 [&x]：共享内存，lambda内修改=外部修改，适合需回写数据
✅ 混合捕获 [x,&y]：兼顾安全+灵活，C++ lambda实战第一选择
 

带有返回值的lambda函数

// 使用尾置返回类型
auto lambda1 = [](int x) -> int {
    return x * 2;
};

// 使用 decltype
auto lambda2 = [](auto x) -> decltype(x * 2) {
    return x * 2;
};