涉及各种高级特性的c++ lambda表达式例子

复杂C++ Lambda表达式，涉及嵌套Lambda、高阶函数、可变捕获、移动捕获、模板参数以及异常处理等概念。

#include <iostream>
#include <functional>
#include <vector>
#include <memory>
#include <stdexcept>

// 一个复杂的Lambda表达式示例
int main() {
    int base = 10;
    std::string message = "Result: ";
    
    // 外层Lambda：捕获局部变量，返回一个函数对象
    auto complex_lambda = [base, msg = std::move(message)](int multiplier) mutable 
        -> std::function<std::string(int)> {
        
        // 修改按值捕获的变量（需要mutable）
        base += 5;
        msg += "Processed: ";
        
        // 内层Lambda：捕获外层Lambda的变量
        auto inner_lambda = [modified_base = base * multiplier, &msg](int value) mutable 
            -> std::string {
            
            try {
                if (value == 0) {
                    throw std::runtime_error("Division by zero attempted");
                }
                
                // 最内层Lambda：进行实际计算
                auto calculator = [](int a, int b) -> double {
                    return static_cast<double>(a) / b;
                };
                
                double result = calculator(modified_base, value);
                msg += "Calculation successful";
                return msg + " -> " + std::to_string(result);
                
            } catch (const std::exception& e) {
                return std::string("Error: ") + e.what();
            }
        };
        
        return inner_lambda;
    };
    
    // 使用Lambda表达式
    auto processor = complex_lambda(3);  // base=15, multiplier=3 → modified_base=45
    std::cout << processor(5) << std::endl;  // 45/5=9.0
    
    // 另一个复杂用例：Lambda与STL算法结合
    std::vector<int> data = {1, 2, 3, 4, 5};
    std::unique_ptr<int> ptr = std::make_unique<int>(100);
    
    std::for_each(data.begin(), data.end(), 
        [captured_ptr = std::move(ptr), index = 0](int& elem) mutable {
            elem += *captured_ptr + index++;
        });
    
    std::cout << "Modified data: ";
    for (int val : data) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

1. ​​多层嵌套Lambda​​

这个示例包含了三层Lambda嵌套 ：

• 外层complex_lambda捕获局部变量并返回函数对象
• 中层inner_lambda捕获外层Lambda的变量
• 内层calculator执行实际计算

2. ​​多种捕获方式​​

• ​​值捕获​​：base按值捕获
   
• ​​引用捕获​​：msg按引用捕获（在内层Lambda中）
   
• ​​移动捕获​​：msg = std::move(message)使用C++14的初始化捕获
   
• ​​移动语义​​：captured_ptr = std::move(ptr)移动智能指针
   

3. ​​高阶函数特性​​

外层Lambda返回一个std::function对象，本身又接受参数，体现了高阶函数的特性。

4. ​​可变捕获与mutable关键字​​

使用mutable关键字允许修改按值捕获的变量base和index。

5. ​​异常处理​​

内层Lambda包含完整的try-catch块，处理可能的除零异常。

6. ​​与STL算法集成​​

示例展示了Lambda与std::for_each算法的结合使用。

这个复杂的例子涵盖了Lambda表达式的大部分高级特性，在实际项目中，这类结构常用于回调机制、异步编程和算法定制等场景。