引言

  在C++11之前，当我们想要在函数内部定义临时函数或向算法传递自定义操作时，通常需要编写独立的函数或定义函数对象（仿函数）。这种方式不仅代码冗长，而且破坏了代码的局部性和可读性。

  C++11引入的Lambda表达式彻底改变了这一局面。Lambda表达式允许我们在需要的地方直接定义匿名函数，使代码更加简洁、表达力更强。如今，Lambda已成为现代C++编程中不可或缺的工具，广泛应用于STL算法、异步编程、事件处理等场景。

  本文将深入探讨C++ Lambda表达式的方方面面，从基础语法到高级特性，帮助你全面掌握这一强大工具。

第一章：Lambda表达式基础

1.1 什么是Lambda表达式？

  Lambda表达式是C++11标准引入的一种定义匿名函数对象的方式。本质上，编译器会将Lambda表达式转换为一个匿名的函数对象类，并创建该类的实例。

传统函数对象 vs Lambda表达式：

// 传统函数对象方式
struct Compare {
    bool operator()(int a, int b) const {
        return a < b;
    }
};

std::vector<int> vec = {3, 1, 4, 1, 5};
Compare comp;
std::sort(vec.begin(), vec.end(), comp);

// Lambda表达式方式
std::vector<int> vec = {3, 1, 4, 1, 5};
std::sort(vec.begin(), vec.end(), [](int a, int b) {
    return a < b;
});

  可以看到，Lambda表达式让代码更加简洁直观。

1.2 基本语法结构

  Lambda表达式的基本语法如下：

[capture_list](parameter_list) -> return_type {
    function_body
}

各个部分的详细说明：

• capture_list：捕获列表，定义Lambda如何访问外部变量
• parameter_list：参数列表，与普通函数的参数列表类似
• return_type：返回类型，可以省略（编译器自动推导）
• function_body：函数体，包含要执行的代码

最简单的Lambda表达式：

// 无参数、无捕获的最简Lambda
auto simplest = []() {};
auto hello = []() { 
    std::cout << "Hello, Lambda!" << std::endl; 
};

// 调用Lambda
hello();  // 输出: Hello, Lambda!

第二章：捕获列表深度解析

  捕获列表是Lambda表达式最强大的特性之一，它决定了Lambda如何访问其定义作用域中的变量。

2.1 值捕获（Copy Capture）

  值捕获将外部变量的值复制到Lambda对象中：

void value_capture_demo() {
    int x = 10;
    int y = 20;
    
    // 值捕获x和y
    auto lambda = [x, y]() {
        std::cout << "Captured values: x=" << x << ", y=" << y << std::endl;
        // x和y是副本，修改它们不会影响外部变量
        // x = 100;  // 错误：值捕获的变量默认是const的
    };
    
    x = 100;  // 修改外部x
    y = 200;  // 修改外部y
    
    lambda();  // 输出: Captured values: x=10, y=20
               // Lambda内部使用的是捕获时的值副本
}

2.2 引用捕获（Reference Capture）

  引用捕获让Lambda直接访问外部变量：

void reference_capture_demo() {
    int counter = 0;
    std::string message = "Hello";
    
    // 引用捕获counter和message
    auto lambda = [&counter, &message]() {
        counter++;
        message += " World";
        std::cout << "Counter: " << counter << ", Message: " << message << std::endl;
    };
    
    lambda();  // 输出: Counter: 1, Message: Hello World
    lambda();  // 输出: Counter: 2, Message: Hello World World
    
    std::cout << "External counter: " << counter << std::endl;  // 输出: 2
    std::cout << "External message: " << message << std::endl;  // 输出: Hello World World
}

2.3 隐式捕获

  隐式捕获让编译器自动推断要捕获的变量：

void implicit_capture_demo() {
    int a = 1, b = 2, c = 3, d = 4;
    
    // 隐式值捕获所有变量
    auto lambda1 = [=]() {
        std::cout << "a=" << a << ", b=" << b << ", c=" << c << ", d=" << d << std::endl;
    };
    
    // 隐式引用捕获所有变量  
    auto lambda2 = [&]() {
        a++; b++; c++; d++;
    };
    
    // 混合捕获：大部分值捕获，特定变量引用捕获
    auto lambda3 = [=, &a]() {
        a++;  // 可以修改a，因为它是引用捕获
        // b++;  // 错误：b是值捕获，不能修改
    };
    
    // 混合捕获：大部分引用捕获，特定变量值捕获
    auto lambda4 = [&, c]() {
        a++; b++; d++;  // 可以修改，因为是引用捕获
        // c++;  // 错误：c是值捕获，不能修改
    };
}

2.4 初始化捕获（C++14）

  C++14引入了初始化捕获，允许在捕获时对变量进行初始化：

void init_capture_demo() {
    int x = 10;
    
    // 初始化值捕获
    auto lambda1 = [value = x + 5]() {
        return value;  // 返回15
    };
    
    // 初始化引用捕获
    auto lambda2 = [&ref = x]() {
        ref += 10;
        return ref;
    };
    
    // 使用移动语义捕获
    auto unique_data = std::make_unique<int>(42);
    auto lambda3 = [data = std::move(unique_data)]() {
        return *data;
    };
    
    // 捕获计算结果
    auto lambda4 = [sqrt_x = std::sqrt(x)]() {
        return sqrt_x;
    };
    
    std::cout << lambda1() << std::endl;  // 输出: 15
    std::cout << lambda2() << std::endl;  // 输出: 20
    std::cout << x << std::endl;          // 输出: 20
    std::cout << lambda3() << std::endl;  // 输出: 42
}

2.5 捕获this指针

  在类的成员函数中，Lambda可以捕获this指针来访问类的成员：

class MyClass {
private:
    int value = 100;
    std::string name = "MyClass";
    
public:
    void demo() {
        // 捕获this指针，访问成员变量
        auto lambda1 = [this]() {
            std::cout << "value: " << value << ", name: " << name << std::endl;
        };
        
        // 值捕获特定成员
        auto lambda2 = [value = this->value]() {
            std::cout << "captured value: " << value << std::endl;
        };
        
        lambda1();
        lambda2();
    }
    
    // 返回Lambda，注意生命周期问题
    auto get_lambda() {
        return [this]() {
            return value;
        };
    }
};

第三章：参数列表与返回类型

3.1 参数列表

  Lambda表达式的参数列表与普通函数类似：

void parameter_demo() {
    // 无参数
    auto no_args = []() { return 42; };
    
    // 基本类型参数
    auto add = [](int a, int b) { return a + b; };
    
    // 引用参数
    auto modify_string = [](std::string& str) {
        str += " modified";
    };
    
    // 常量引用参数（推荐用于大对象）
    auto print_size = [](const std::vector<int>& vec) {
        return vec.size();
    };
    
    // 默认参数（C++14）
    auto with_default = [](int x, int y = 10) {
        return x + y;
    };
    
    std::cout << add(5, 3) << std::endl;  // 输出: 8
    
    std::string text = "Hello";
    modify_string(text);
    std::cout << text << std::endl;  // 输出: Hello modified
    
    std::vector<int> numbers = {1, 2, 3};
    std::cout << print_size(numbers) << std::endl;  // 输出: 3
    
    std::cout << with_default(5) << std::endl;  // 输出: 15
}

3.2 返回类型

  Lambda表达式的返回类型可以通过多种方式指定：

void return_type_demo() {
    // 自动推导返回类型
    auto auto_deduced = [](int x) { return x * 2; };
    
    // 显式指定返回类型
    auto explicit_return = [](double a, double b) -> int {
        return static_cast<int>(a + b);
    };
    
    // 复杂返回类型
    auto create_vector = [](int size) -> std::vector<int> {
        return std::vector<int>(size, 0);
    };
    
    // 返回引用
    int value = 100;
    auto return_ref = [&value]() -> int& {
        return value;
    };
    
    // 多返回路径需要显式指定返回类型
    auto conditional = [](int x) -> double {
        if (x > 0) {
            return x * 1.5;
        } else {
            return x * 0.5;
        }
    };
    
    std::cout << auto_deduced(21) << std::endl;      // 输出: 42
    std::cout << explicit_return(3.14, 2.71) << std::endl;  // 输出: 5
    
    auto& ref = return_ref();
    ref = 200;
    std::cout << value << std::endl;  // 输出: 200
}

3.3 可变Lambda（mutable）

  默认情况下，值捕获的变量在Lambda体内是const的，使用mutable关键字可以修改它们：

void mutable_demo() {
    int external = 10;
    
    // 没有mutable，不能修改值捕获的变量
    auto lambda1 = [external]() {
        // external++;  // 错误：不能修改值捕获的变量
        return external;
    };
    
    // 使用mutable，可以修改值捕获的变量
    auto lambda2 = [external]() mutable {
        external++;  // 可以修改，但修改的是副本
        return external;
    };
    
    std::cout << "Before: external = " << external << std::endl;  // 输出: 10
    std::cout << "lambda2(): " << lambda2() << std::endl;         // 输出: 11
    std::cout << "lambda2(): " << lambda2() << std::endl;         // 输出: 12
    std::cout << "After: external = " << external << std::endl;   // 输出: 10（不变）
    
    // mutable与引用捕获
    auto lambda3 = [&external]() mutable {  // mutable对引用捕获没有影响
        external++;  // 可以直接修改外部变量
    };
    
    lambda3();
    std::cout << "After lambda3: external = " << external << std::endl;  // 输出: 11
}

第四章：Lambda表达式实战应用

4.1 STL算法中的Lambda

  Lambda表达式与STL算法完美配合，大大提升了代码的可读性和简洁性：

#include <vector>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <string>

void stl_algorithms_demo() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
    
    // 1. 排序：按绝对值排序
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return std::abs(a) < std::abs(b);
    });
    std::cout << "Sorted by absolute value: ";
    for (int n : numbers) std::cout << n << " ";
    std::cout << std::endl;
    
    // 2. 查找：查找第一个大于5的偶数
    auto it = std::find_if(numbers.begin(), numbers.end(), [](int n) {
        return n > 5 && n % 2 == 0;
    });
    if (it != numbers.end()) {
        std::cout << "First even number greater than 5: " << *it << std::endl;
    }
    
    // 3. 计数：统计奇数的个数
    int odd_count = std::count_if(numbers.begin(), numbers.end(), [](int n) {
        return n % 2 != 0;
    });
    std::cout << "Number of odd numbers: " << odd_count << std::endl;
    
    // 4. 变换：将数字转换为字符串
    std::vector<std::string> number_strings;
    std::transform(numbers.begin(), numbers.end(), 
                  std::back_inserter(number_strings),
                  [](int n) { return std::to_string(n); });
    
    // 5. 删除：删除所有小于3的数字
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(),
                                [](int n) { return n < 3; }),
                  numbers.end());
    
    // 6. 遍历：输出剩余数字
    std::cout << "Numbers after removal: ";
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl;
    
    // 7. 累加：自定义累加器
    std::vector<std::pair<int, std::string>> pairs = {
        {1, "apple"}, {2, "banana"}, {3, "cherry"}
    };
    
    auto concatenate = [](const std::string& a, const std::pair<int, std::string>& b) {
        return a + (a.empty() ? "" : ", ") + b.second;
    };
    
    std::string result = std::accumulate(pairs.begin(), pairs.end(), 
                                        std::string(), concatenate);
    std::cout << "Concatenated: " << result << std::endl;
}

4.2 异步编程与多线程

  Lambda表达式极大地简化了异步编程和多线程代码：

#include <future>
#include <thread>
#include <vector>
#include <numeric>
#include <chrono>

void async_multithreading_demo() {
    // 1. 使用std::async执行异步任务
    auto future = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return "Hello from async task!";
    });
    
    // 主线程可以继续做其他工作
    std::cout << "Main thread is working..." << std::endl;
    
    // 获取异步任务结果
    std::string result = future.get();
    std::cout << result << std::endl;
    
    // 2. 并行计算：使用多个线程处理数据
    std::vector<int> data(1000);
    std::iota(data.begin(), data.end(), 1);  // 填充1-1000
    
    // 分块处理数据
    const size_t chunk_size = data.size() / 4;
    std::vector<std::future<int>> futures;
    
    for (int i = 0; i < 4; ++i) {
        auto start = data.begin() + i * chunk_size;
        auto end = (i == 3) ? data.end() : start + chunk_size;
        
        futures.push_back(std::async(std::launch::async, 
            [start, end]() {
                return std::accumulate(start, end, 0);
            }));
    }
    
    // 收集结果
    int total_sum = 0;
    for (auto& future : futures) {
        total_sum += future.get();
    }
    
    std::cout << "Parallel sum: " << total_sum << std::endl;
    std::cout << "Expected sum: " << (1000 * 1001) / 2 << std::endl;
    
    // 3. 使用std::thread创建线程
    std::vector<std::thread> threads;
    std::mutex cout_mutex;
    
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back([i, &cout_mutex]() {
            std::lock_guard<std::mutex> lock(cout_mutex);
            std::cout << "Thread " << i << " is running" << std::endl;
        });
    }
    
    for (auto& thread : threads) {
        thread.join();
    }
}

4.3 事件处理与回调机制

  Lambda表达式非常适合用于事件处理和回调函数：

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

class EventSystem {
public:
    using EventHandler = std::function<void(const std::string&)>;
    
    void subscribe(const std::string& event_type, EventHandler handler) {
        handlers[event_type].push_back(handler);
    }
    
    void publish(const std::string& event_type, const std::string& data) {
        auto it = handlers.find(event_type);
        if (it != handlers.end()) {
            for (auto& handler : it->second) {
                handler(data);
            }
        }
    }
    
private:
    std::unordered_map<std::string, std::vector<EventHandler>> handlers;
};

class Button {
public:
    using ClickHandler = std::function<void()>;
    
    void setOnClick(ClickHandler handler) {
        onClick = handler;
    }
    
    void click() {
        if (onClick) {
            onClick();
        }
    }
    
private:
    ClickHandler onClick;
};

void event_callback_demo() {
    // 1. 事件系统示例
    EventSystem event_system;
    int click_count = 0;
    
    // 订阅点击事件
    event_system.subscribe("click", [&click_count](const std::string& data) {
        click_count++;
        std::cout << "Click event #" << click_count << ": " << data << std::endl;
    });
    
    // 订阅数据加载事件
    event_system.subscribe("data_loaded", [](const std::string& data) {
        std::cout << "Data loaded: " << data << std::endl;
    });
    
    // 发布事件
    event_system.publish("click", "Button A");
    event_system.publish("data_loaded", "User profile");
    event_system.publish("click", "Button B");
    
    // 2. UI控件回调示例
    Button button;
    int press_count = 0;
    
    button.setOnClick([&press_count]() {
        press_count++;
        std::cout << "Button pressed! Count: " << press_count << std::endl;
    });
    
    // 模拟按钮点击
    button.click();
    button.click();
    button.click();
    
    // 3. 定时器回调
    auto create_timer = [](int interval, std::function<void()> callback) {
        return [interval, callback]() {
            std::cout << "Timer set for " << interval << "ms" << std::endl;
            // 在实际应用中，这里会启动一个定时器
            callback();
        };
    };
    
    auto timer = create_timer(1000, []() {
        std::cout << "Timer expired!" << std::endl;
    });
    
    timer();
}

4.4 资源管理与RAII

  Lambda表达式可以与RAII模式结合，实现优雅的资源管理：

#include <fstream>
#include <memory>
#include <mutex>

void resource_management_demo() {
    // 1. 文件操作：使用Lambda确保文件正确关闭
    auto read_file = [](const std::string& filename) -> std::string {
        std::ifstream file(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Cannot open file: " + filename);
        }
        
        // 使用Lambda读取文件内容
        return [&file]() -> std::string {
            std::string content;
            std::string line;
            while (std::getline(file, line)) {
                content += line + "\n";
            }
            return content;
        }();  // 立即调用Lambda
        // 文件在Lambda结束时自动关闭
    };
    
    try {
        auto content = read_file("example.txt");
        std::cout << "File content length: " << content.length() << std::endl;
    } catch (const std::exception& e) {
        std::cout << "Error: " << e.what() << std::endl;
    }
    
    // 2. 互斥锁保护
    std::mutex data_mutex;
    std::vector<int> shared_data = {1, 2, 3, 4, 5};
    
    auto safe_data_access = [&shared_data, &data_mutex]() {
        std::lock_guard<std::mutex> lock(data_mutex);
        
        // 在锁保护下操作数据
        return [&shared_data]() {
            int sum = 0;
            for (int value : shared_data) {
                sum += value;
            }
            shared_data.push_back(sum);  // 修改数据
            return sum;
        }();
    };
    
    std::cout << "Sum with protection: " << safe_data_access() << std::endl;
    
    // 3. 自定义RAII类与Lambda
    class ScopeGuard {
    public:
        explicit ScopeGuard(std::function<void()> cleanup) 
            : cleanup_(std::move(cleanup)) {}
        
        ~ScopeGuard() {
            if (cleanup_) {
                cleanup_();
            }
        }
        
        // 禁止拷贝
        ScopeGuard(const ScopeGuard&) = delete;
        ScopeGuard& operator=(const ScopeGuard&) = delete;
        
    private:
        std::function<void()> cleanup_;
    };
    
    {
        std::cout << "Entering guarded scope" << std::endl;
        ScopeGuard guard([]() {
            std::cout << "Cleanup action executed" << std::endl;
        });
        std::cout << "Working inside guarded scope" << std::endl;
    }  // 离开作用域时自动执行清理
    std::cout << "Left guarded scope" << std::endl;
}

第五章：高级特性与技巧

5.1 泛型Lambda（C++14）

  C++14引入了泛型Lambda，使用auto参数让Lambda可以处理多种类型：

#include <type_traits>
#include <vector>
#include <list>

void generic_lambda_demo() {
    // 1. 基本泛型Lambda
    auto generic_add = [](auto a, auto b) {
        return a + b;
    };
    
    // 可以用于各种类型
    std::cout << generic_add(5, 3) << std::endl;                    // int: 8
    std::cout << generic_add(2.5, 3.7) << std::endl;               // double: 6.2
    std::cout << generic_add(std::string("Hello"), " World") << std::endl;  // string
    
    // 2. 容器操作的泛型Lambda
    auto print_container = [](const auto& container) {
        for (const auto& item : container) {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    };
    
    std::vector<int> int_vec = {1, 2, 3};
    std::list<std::string> str_list = {"a", "b", "c"};
    
    print_container(int_vec);   // 输出: 1 2 3
    print_container(str_list);  // 输出: a b c
    
    // 3. 类型约束的泛型Lambda
    auto numeric_operations = [](auto a, auto b) {
        static_assert(std::is_arithmetic_v<decltype(a)> && 
                     std::is_arithmetic_v<decltype(b)>,
                     "Both arguments must be numeric types");
        
        return std::make_pair(a + b, a * b);
    };
    
    auto [sum, product] = numeric_operations(4, 5);
    std::cout << "Sum: " << sum << ", Product: " << product << std::endl;
    
    // 4. 递归泛型Lambda（需要显式指定返回类型）
    auto factorial = [](auto n) -> decltype(n) {
        if (n <= 1) return 1;
        return n * factorial(n - 1);
    };
    
    std::cout << "Factorial of 5: " << factorial(5) << std::endl;
    
    // 5. 完美转发泛型Lambda
    auto forward_example = [](auto&&... args) {
        return some_function(std::forward<decltype(args)>(args)...);
    };
}

5.2 constexpr Lambda（C++17）

  C++17允许Lambda表达式在编译期求值：

#include <array>

void constexpr_lambda_demo() {
    // 1. 基本constexpr Lambda
    constexpr auto square = [](int n) constexpr { return n * n; };
    
    // 编译期计算
    static_assert(square(5) == 25);
    std::array<int, square(3)> arr;  // 数组大小为9
    
    // 2. 条件constexpr
    constexpr auto factorial = [](int n) constexpr {
        if (n <= 1) return 1;
        return n * factorial(n - 1);
    };
    
    static_assert(factorial(5) == 120);
    
    // 3. 在模板中使用constexpr Lambda
    template<auto Func>
    struct ComputedValue {
        static constexpr auto value = Func();
    };
    
    constexpr auto compute = []() constexpr { return 42; };
    ComputedValue<compute> obj;
    
    // 4. 编译期字符串处理
    constexpr auto string_length = [](const char* str) constexpr {
        int len = 0;
        while (str[len] != '\0') ++len;
        return len;
    };
    
    static_assert(string_length("Hello") == 5);
    
    // 5. 编译期算法
    constexpr auto find_max = [](auto&& range) constexpr {
        auto max_val = range[0];
        for (const auto& item : range) {
            if (item > max_val) max_val = item;
        }
        return max_val;
    };
    
    constexpr std::array<int, 4> numbers = {3, 1, 4, 2};
    static_assert(find_max(numbers) == 4);
    
    std::cout << "All constexpr assertions passed!" << std::endl;
}

5.3 模板Lambda（C++20）

  C++20为Lambda引入了模板语法，提供了更强的类型控制：

#include <concepts>
#include <ranges>

void template_lambda_demo() {
    // 1. 基本模板Lambda
    auto template_lambda = []<typename T>(T a, T b) -> T {
        return a + b;
    };
    
    std::cout << template_lambda(5, 3) << std::endl;        // 8
    std::cout << template_lambda(2.5, 3.7) << std::endl;   // 6.2
    
    // 2. 多类型模板参数
    auto multi_type = []<typename T, typename U>(T a, U b) -> decltype(a + b) {
        return a + b;
    };
    
    // 3. 模板参数包
    auto variadic_template = []<typename... Ts>(Ts... args) {
        return sizeof...(args);
    };
    
    std::cout << "Number of args: " << variadic_template(1, 2.0, "three") << std::endl;
    
    // 4. 概念约束（C++20）
    auto numeric_lambda = []<std::integral T>(T a, T b) {
        return a + b;
    };
    
    auto container_lambda = []<std::ranges::range Container>(const Container& c) {
        return c.size();
    };
    
    // 5. 类型特化
    auto specialized = []<typename T>(T value) {
        if constexpr (std::is_pointer_v<T>) {
            return *value;
        } else {
            return value;
        }
    };
    
    int x = 42;
    int* ptr = &x;
    std::cout << specialized(100) << std::endl;    // 100
    std::cout << specialized(ptr) << std::endl;     // 42
    
    // 6. 完美转发模板Lambda
    auto forward_lambda = []<typename... Args>(Args&&... args) {
        return some_function(std::forward<Args>(args)...);
    };
}

5.4 Lambda表达式与SFINAE

  Lambda表达式可以与SFINAE技术结合，实现更复杂的编译期逻辑：

#include <type_traits>

template<typename T>
auto detect_capabilities() {
    // 检测是否有size()方法
    auto has_size = [](auto&& obj) -> decltype(obj.size(), std::true_type{}) {
        return {};
    };
    
    // 检测是否有begin()和end()方法  
    auto is_iterable = [](auto&& obj) -> 
        decltype(obj.begin(), obj.end(), std::true_type{}) {
        return {};
    };
    
    // 失败回退
    auto fallback = [](...) { return std::false_type{}; };
    
    if constexpr (decltype(has_size(std::declval<T>()))::value) {
        std::cout << "Type has size() method" << std::endl;
    }
    
    if constexpr (decltype(is_iterable(std::declval<T>()))::value) {
        std::cout << "Type is iterable" << std::endl;
    }
}

void sfinae_demo() {
    std::vector<int> vec;
    detect_capabilities<decltype(vec)>();
    
    int x;
    detect_capabilities<decltype(x)>();
}

第六章：注意事项与最佳实践

6.1 生命周期管理

  Lambda表达式的生命周期管理是使用中最容易出错的地方：

#include <memory>
#include <functional>

void lifetime_management_demo() {
    // 1. 危险的引用捕获
    std::function<void()> create_dangerous_lambda() {
        int local_var = 42;
        
        // 危险：捕获了即将销毁的局部变量的引用
        return [&local_var]() {
            std::cout << local_var << std::endl;  // 未定义行为！
        };
    }
    
    // 2. 安全的解决方案
    std::function<void()> create_safe_lambda() {
        // 方案1：值捕获
        int local_var = 42;
        return [local_var]() {  // 复制值
            std::cout << local_var << std::endl;  // 安全
        };
        
        // 方案2：使用shared_ptr
        auto data = std::make_shared<int>(42);
        return [data]() {
            std::cout << *data << std::endl;  // 安全
        };
        
        // 方案3：移动捕获（C++14）
        auto unique_data = std::make_unique<int>(42);
        return [data = std::move(unique_data)]() {
            std::cout << *data << std::endl;  // 安全
        };
    }
    
    // 3. 类成员捕获的生命周期
    class ResourceOwner {
    private:
        std::string resource = "Important Resource";
        std::vector<std::function<void()>> callbacks;
        
    public:
        // 危险：捕获this指针，但对象可能已销毁
        void register_unsafe_callback() {
            callbacks.push_back([this]() {
                std::cout << resource << std::endl;  // 可能访问已销毁的对象
            });
        }
        
        // 安全：使用weak_ptr
        void register_safe_callback(std::weak_ptr<ResourceOwner> weak_this) {
            callbacks.push_back([weak_this]() {
                if (auto shared_this = weak_this.lock()) {
                    std::cout << shared_this->resource << std::endl;
                } else {
                    std::cout << "Object no longer exists" << std::endl;
                }
            });
        }
        
        ~ResourceOwner() {
            std::cout << "ResourceOwner destroyed" << std::endl;
        }
    };
    
    // 4. Lambda存储在容器中的生命周期
    auto store_lambdas = []() {
        std::vector<std::function<void()>> lambda_storage;
        
        {
            int temp_data = 100;
            
            // 危险：存储捕获局部变量引用的Lambda
            lambda_storage.push_back([&temp_data]() {
                std::cout << temp_data << std::endl;  // 危险！
            });
            
            // 安全：值捕获或共享所有权
            lambda_storage.push_back([data = temp_data]() {
                std::cout << data << std::endl;  // 安全
            });
        }  // temp_data离开作用域
        
        // 调用存储的Lambda
        for (auto& lambda : lambda_storage) {
            lambda();  // 第一个Lambda会导致未定义行为
        }
    };
}

6.2 性能优化

  合理使用Lambda表达式可以提升性能，但也需要注意潜在的性能问题：

#include <chrono>

void performance_optimization_demo() {
    // 1. 内联优化
    // 小的Lambda通常会被编译器内联，性能很好
    auto fast_lambda = [](int x) { return x * x; };
    
    // 2. 避免不必要的捕获
    std::vector<int> large_data(10000, 42);
    
    // 不好：捕获大对象
    auto inefficient = [large_data]() {  // 复制整个vector
        return large_data.size();
    };
    
    // 更好：引用捕获或传递参数
    auto efficient1 = [&large_data]() {  // 只捕获引用
        return large_data.size();
    };
    
    auto efficient2 = [](const std::vector<int>& data) {  // 参数传递
        return data.size();
    };
    
    // 3. 移动语义优化
    auto create_heavy_object = []() {
        return std::vector<int>(1000, 42);
    };
    
    auto process_with_move = [data = create_heavy_object()]() mutable {
        // 使用移动语义避免复制
        auto processed = std::move(data);
        // 处理数据...
        return processed.size();
    };
    
    // 4. 编译期计算优化
    constexpr auto compile_time_compute = [](int n) constexpr {
        int result = 0;
        for (int i = 1; i <= n; ++i) {
            result += i;
        }
        return result;
    };
    
    // 编译期计算，零运行时开销
    constexpr int sum_100 = compile_time_compute(100);
    
    // 5. 避免在热点路径中创建Lambda
    void process_data(std::vector<int>& data) {
        // 不好：在循环中重复创建相同的Lambda
        for (auto& item : data) {
            auto transformer = [](int x) { return x * 2 + 1; };  // 重复创建
            item = transformer(item);
        }
        
        // 更好：在循环外创建Lambda
        auto transformer = [](int x) { return x * 2 + 1; };
        for (auto& item : data) {
            item = transformer(item);
        }
        
        // 最好：使用STL算法
        std::transform(data.begin(), data.end(), data.begin(),
                      [](int x) { return x * 2 + 1; });
    }
    
    // 6. 性能测试
    auto benchmark = []() {
        const int iterations = 1000000;
        std::vector<int> test_data(iterations);
        
        auto start = std::chrono::high_resolution_clock::now();
        
        // 测试Lambda性能
        std::generate(test_data.begin(), test_data.end(), 
                     [n = 0]() mutable { return n++; });
        
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        
        std::cout << "Lambda operation took: " << duration.count() << " microseconds" << std::endl;
    };
    
    benchmark();
}

6.3 调试与维护

  编写易于调试和维护的Lambda表达式：

#include <sstream>

void debugging_maintenance_demo() {
    // 1. 命名复杂的Lambda
    // 不好的写法：过于复杂的匿名Lambda
    auto result1 = std::accumulate(begin, end, 0, 
        [](int acc, auto&& item) { 
            return item.is_valid() && item.value() > threshold ? 
                   acc + item.weight() * factor : acc; 
        });
    
    // 好的写法：命名并分解复杂逻辑
    auto calculate_weighted_sum = [threshold, factor](int accumulator, const auto& item) {
        if (!item.is_valid() || item.value() <= threshold) {
            return accumulator;
        }
        return accumulator + item.weight() * factor;
    };
    
    auto result2 = std::accumulate(begin, end, 0, calculate_weighted_sum);
    
    // 2. 添加注释说明复杂的捕获逻辑
    auto complex_capture_lambda = [database = get_database(), 
                                  &cache = global_cache,
                                  config = load_config()]() {
        // 注意：
        // - database: 移动捕获，获取数据库连接所有权
        // - cache: 引用捕获全局缓存，修改会影响其他部分
        // - config: 值捕获配置，Lambda有自己的副本
        
        // 复杂业务逻辑...
    };
    
    // 3. 使用static_assert进行编译期检查
    auto type_safe_lambda = [](auto value) {
        static_assert(std::is_arithmetic_v<decltype(value)>,
                     "Value must be arithmetic type");
        return value * 2;
    };
    
    // 4. 错误处理
    auto safe_operation = [](const std::string& input) -> std::optional<int> {
        try {
            if (input.empty()) {
                return std::nullopt;
            }
            return std::stoi(input);
        } catch (const std::exception& e) {
            std::cerr << "Conversion failed: " << e.what() << std::endl;
            return std::nullopt;
        }
    };
    
    // 5. 日志记录
    auto logged_operation = [](auto operation, const std::string& name) {
        return [operation, name](auto&&... args) {
            std::cout << "Starting operation: " << name << std::endl;
            auto start = std::chrono::steady_clock::now();
            
            try {
                auto result = operation(std::forward<decltype(args)>(args)...);
                auto end = std::chrono::steady_clock::now();
                auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                std::cout << "Operation " << name << " completed in " 
                         << duration.count() << "ms" << std::endl;
                return result;
            } catch (const std::exception& e) {
                std::cerr << "Operation " << name << " failed: " << e.what() << std::endl;
                throw;
            }
        };
    };
    
    // 使用日志包装器
    auto safe_divide = logged_operation([](int a, int b) { return a / b; }, "division");
    
    try {
        auto result = safe_divide(10, 2);  // 输出日志信息
    } catch (...) {
        // 处理异常
    }
}

第七章：实际项目中的应用模式

7.1 策略模式与Lambda

  Lambda表达式可以简化策略模式的实现：

#include <vector>
#include <algorithm>

void strategy_pattern_demo() {
    // 传统策略模式
    class SortingStrategy {
    public:
        virtual ~SortingStrategy() = default;
        virtual void sort(std::vector<int>& data) const = 0;
    };
    
    class AscendingStrategy : public SortingStrategy {
    public:
        void sort(std::vector<int>& data) const override {
            std::sort(data.begin(), data.end());
        }
    };
    
    class DescendingStrategy : public SortingStrategy {
    public:
        void sort(std::vector<int>& data) const override {
            std::sort(data.begin(), data.end(), std::greater<int>());
        }
    };
    
    // 使用Lambda的策略模式
    using SortingStrategyLambda = std::function<void(std::vector<int>&)>;
    
    SortingStrategyLambda ascending = [](std::vector<int>& data) {
        std::sort(data.begin(), data.end());
    };
    
    SortingStrategyLambda descending = [](std::vector<int>& data) {
        std::sort(data.begin(), data.end(), std::greater<int>());
    };
    
    SortingStrategyLambda custom = [](std::vector<int>& data) {
        std::sort(data.begin(), data.end(), [](int a, int b) {
            return std::abs(a) < std::abs(b);  // 按绝对值排序
        });
    };
    
    // 策略上下文
    class Sorter {
    private:
        SortingStrategyLambda strategy;
        
    public:
        void setStrategy(SortingStrategyLambda new_strategy) {
            strategy = std::move(new_strategy);
        }
        
        void execute(std::vector<int>& data) {
            if (strategy) {
                strategy(data);
            }
        }
    };
    
    // 使用示例
    Sorter sorter;
    std::vector<int> numbers = {3, -1, 4, -1, 5, 9, -2, 6};
    
    sorter.setStrategy(ascending);
    sorter.execute(numbers);
    std::cout << "Ascending: ";
    for (int n : numbers) std::cout << n << " ";
    std::cout << std::endl;
    
    sorter.setStrategy(descending);
    sorter.execute(numbers);
    std::cout << "Descending: ";
    for (int n : numbers) std::cout << n << " ";
    std::cout << std::endl;
    
    sorter.setStrategy(custom);
    sorter.execute(numbers);
    std::cout << "By absolute: ";
    for (int n : numbers) std::cout << n << " ";
    std::cout << std::endl;
}

7.2 工厂模式与Lambda

  Lambda表达式可以用于创建灵活的工厂模式：

#include <memory>
#include <unordered_map>

void factory_pattern_demo() {
    // 传统工厂模式
    class Product {
    public:
        virtual ~Product() = default;
        virtual void operation() = 0;
    };
    
    class ConcreteProductA : public Product {
    public:
        void operation() override {
            std::cout << "Product A operation" << std::endl;
        }
    };
    
    class ConcreteProductB : public Product {
    public:
        void operation() override {
            std::cout << "Product B operation" << std::endl;
        }
    };
    
    // 使用Lambda的工厂模式
    using ProductFactory = std::function<std::unique_ptr<Product>()>;
    
    std::unordered_map<std::string, ProductFactory> factories;
    
    // 注册工厂函数
    factories["A"] = []() -> std::unique_ptr<Product> {
        return std::make_unique<ConcreteProductA>();
    };
    
    factories["B"] = []() -> std::unique_ptr<Product> {
        return std::make_unique<ConcreteProductB>();
    };
    
    // 带参数的工厂
    factories["custom"] = [](const std::string& config) -> std::unique_ptr<Product> {
        if (config == "fast") {
            return std::make_unique<ConcreteProductA>();
        } else {
            return std::make_unique<ConcreteProductB>();
        }
    };
    
    // 产品创建
    auto create_product = [&factories](const std::string& type) {
        auto it = factories.find(type);
        if (it != factories.end()) {
            return it->second();
        }
        return std::unique_ptr<Product>{};
    };
    
    auto product_a = create_product("A");
    auto product_b = create_product("B");
    
    if (product_a) product_a->operation();
    if (product_b) product_b->operation();
}

7.3 观察者模式与Lambda

  Lambda表达式简化了观察者模式的实现：

#include <set>
#include <string>

void observer_pattern_demo() {
    // 使用Lambda的观察者模式
    template<typename T>
    class Observable {
    private:
        std::set<std::function<void(const T&)>> observers;
        
    public:
        void subscribe(std::function<void(const T&)> observer) {
            observers.insert(observer);
        }
        
        void unsubscribe(std::function<void(const T&)> observer) {
            observers.erase(observer);
        }
        
        void notify(const T& data) {
            for (const auto& observer : observers) {
                observer(data);
            }
        }
    };
    
    // 使用示例：温度监控系统
    class TemperatureSensor {
    private:
        Observable<double> temperature_observable;
        double current_temperature = 20.0;
        
    public:
        void set_temperature(double temp) {
            current_temperature = temp;
            temperature_observable.notify(temp);
        }
        
        auto get_observable() { return &temperature_observable; }
    };
    
    TemperatureSensor sensor;
    
    // 订阅温度变化
    int warning_count = 0;
    sensor.get_observable()->subscribe([&warning_count](double temp) {
        std::cout << "Current temperature: " << temp << "°C" << std::endl;
        
        if (temp > 30.0) {
            warning_count++;
            std::cout << "WARNING: High temperature detected!" << std::endl;
        }
    });
    
    // 另一个订阅者：记录温度历史
    std::vector<double> temperature_history;
    sensor.get_observable()->subscribe([&temperature_history](double temp) {
        temperature_history.push_back(temp);
        std::cout << "History size: " << temperature_history.size() << std::endl;
    });
    
    // 模拟温度变化
    sensor.set_temperature(25.0);
    sensor.set_temperature(32.0);
    sensor.set_temperature(28.0);
    
    std::cout << "Total warnings: " << warning_count << std::endl;
}

总结

  C++ Lambda表达式是现代C++编程中不可或缺的强大工具。通过本文的详细讲解，我们了解了：

1. 基础语法：从最简单的Lambda到复杂的捕获列表
2. 高级特性：泛型Lambda、constexpr Lambda、模板Lambda等
3. 实战应用：STL算法、异步编程、事件处理等场景
4. 最佳实践：生命周期管理、性能优化、调试技巧
5. 设计模式：如何用Lambda简化传统设计模式

  Lambda表达式的优势在于：

• 简洁性：减少样板代码，提高可读性
• 灵活性：支持多种捕获方式和参数类型
• 表达力：使代码意图更加清晰
• 性能：小的Lambda通常会被内联优化