【C++】Lambda表达式

一、Lambda表达式基础

1.1 核心概念

Lambda表达式是C++11引入的匿名函数对象，具有以下特点：

• 就地定义，无需单独命名
• 可捕获上下文变量
• 自动推导返回类型（多数情况）
• 可作为函数参数传递

1.2 基础语法

[capture](parameters) mutable -> return_type { 
    // 函数体 
}

含义：

1. [capture]：捕获列表，用于指定Lambda如何访问外部变量。

2. (parameters)：参数列表，和普通函数的参数类似，但需要注意Lambda参数C++14起才支持auto类型。且不允许有默认参数。

3. mutable：这个关键字的作用是允许修改按值捕获的变量，或者调用非const的成员函数。默认情况下Lambda的operator()是const的，所以不加mutable的话，无法修改按值捕获的变量。

4. return_type：返回类型，通常可以自动推导，但在某些情况下需要显式指定，比如函数体内有多个return语句且返回类型不一致时。

5. 函数体：Lambda的具体实现代码，和普通函数类似，但可以访问捕获的变量。

最小示例：

auto greet = [] { std::cout << "Hello Lambda!"; };
greet();  // 输出：Hello Lambda!

二、捕获列表详解

2.1 捕获方式对比

2.2 捕获示例

int main() 
{
    int a = 10, b = 20;
    
    // 值捕获示例
    auto value_capture = [a] { 
        return a * 2;              // 捕获时的值：a = 10
    };
    a = 100;                       // a修改，不影响之前值捕获的值，因为创建时拷贝了
    std::cout << value_capture();  // 输出：20

    // 引用捕获示例
    auto ref_capture = [&b] {
        b += 5;                    // 直接修改原变量
    };
    ref_capture();
    std::cout << b;                // 输出：25
}

三、参数与返回类型

3.1 参数传递

// 显式参数类型
auto add_int = [](int a, int b) { return a + b; };

// C++14起支持auto参数
auto generic_add = [](auto x, auto y) { return x + y; };

std::cout << add_int(3, 5);         // 输出：8
std::cout << generic_add(2.5, 3.7); // 输出：6.2

3.2 返回类型推导

当函数体包含多个return语句且类型不同时，需要显式指定返回类型：

auto safe_divide = [](int x, int y) -> double {
    if(y == 0)
    {
        return 0.0;
    }  
    else 
    {
        return x / static_cast<double>(y);
    }
};

四、高级特性与应用

4.1 立即执行Lambda

const auto result = [](int base) {
    int sum = 0;
    for(int i = 1; i <= base; ++i) 
    {
        sum += i;
    }
    return sum;
}(100);               // 立即计算1-100的和

std::cout << result;  // 输出：5050

4.2 泛型Lambda（C++14）

auto make_adder = [](auto increment) {
    return [increment](auto x) { return x + increment; };
};

auto add5 = make_adder(5);
std::cout << add5(3.14);     // 输出：8.14
std::cout << add5("abc");    // 编译错误（字符串不能+5）

4.3 捕获表达式（C++14）

int x = 10;
auto lambda = [y = x * 2] {  // 初始化捕获
    return y + 5; 
};
std::cout << lambda();       // 输出：25

4.4 递归Lambda

auto factorial = [](auto self, int n) -> int {
    return n <= 1 ? 1 : n * self(self, n-1);
};
std::cout << factorial(factorial, 5);  // 输出：120

五、典型应用场景

5.1 STL算法

std::vector<int> numbers{3, 1, 4, 1, 5, 9, 2, 6};
std::sort(numbers.begin(), numbers.end(), 
    [](int a, int b) { return a > b; });              // 降序排列

int count = std::count_if(numbers.begin(), numbers.end(),
    [threshold=5](int x) { return x > threshold; });  // 统计大于5的元素

5.2 多线程编程

#include <thread>
#include <vector>

void parallel_process() {
    std::vector<std::thread> workers;
    for(int i=0; i<5; ++i) 
    {
        workers.emplace_back([i] {  // 每个线程捕获不同的i值
            std::cout << "Thread " << i << " working\n";
        });
    }
    for(auto& t : workers)
    {
        t.join();
    }
}

5.3 延迟执行

auto create_logger = [](const std::string& prefix) {
    return [=](const auto& message) {   // 值捕获prefix
        std::cout << "[" << prefix << "] " << message << "\n";
    };
};

auto error_log = create_logger("ERROR");
error_log("File not found");            // [ERROR] File not found

六、注意事项

6.1 悬挂引用

auto create_dangerous_lambda() {
    int local = 42;
    return [&local] { return local; };  // 危险！
}                                       // local离开作用域被销毁

auto bad_lambda = create_dangerous_lambda();
std::cout << bad_lambda();              // 未定义行为！

解决方案：使用值捕获或shared_ptr

auto create_safe_lambda() {
    auto ptr = std::make_shared<int>(42);
    return [ptr] { return *ptr; };      // 共享所有权
}

6.2 捕获this指针

class Widget {
    int value = 100;
public:
    auto get_handler() {
        return [this] {                 // 捕获当前对象指针
            return value * 2; 
        };
    }
};

七、性能优化建议

1. 小Lambda优先传值：避免不必要的引用捕获开销
2. 避免在循环中创建大型Lambda：可能影响缓存局部性
3. 慎用[=]和[&]：明确捕获需要的变量
4. 考虑const correctness：默认operator()是const的

八、C++标准演进

九、最佳实践总结

1. 保持简洁：Lambda最适合短小逻辑
2. 明确捕获：避免隐式捕获所有变量
3. 注意生命周期：引用捕获需确保有效性
4. 合理使用auto：简化泛型Lambda声明
5. 性能敏感区谨慎使用：理解编译器生成的开销

// 综合示例：工厂模式
auto create_multiplier(int factor) 
{
    return [factor](int x) mutable {  // 值捕获factor
        factor += x % 2;              // 修改拷贝的值
        return x * factor;
    };
}

auto doubler = create_multiplier(2);
std::cout << doubler(5);             // 5*2=10
std::cout << doubler(3);             // 3*(2+1)=9

如果这篇文章对你有所帮助，渴望获得你的一个点赞！