Lambda 表达式

[capture](params) mutable -> Ret { body }

// 用户写的 Lambda
int x = 10;
auto lambda = [x](int y) { return x + y; };

// 编译器等价生成（简化）
class __anonymous {
    int x;  // 捕获的副本
public:
    __anonymous(int x_) : x(x_) {}
    auto operator()(int y) const { return x + y; }
};

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

struct Student {
    std::string name;
    int score;
    std::string major;
};

int main() {
    std::vector<Student> students = {
        {"张三", 92, "计算机科学"},
        {"李四", 78, "数学"},
        {"王五", 85, "计算机科学"},
        {"赵六", 88, "物理"},
        {"钱七", 95, "计算机科学"},
        {"孙八", 60, "数学"}
    };

    std::cout << "===== 原始成绩单 =====" << std::endl;
    for (const auto& s : students) {
        std::cout << s.name << " | " << s.score << " | " << s.major << std::endl;
    }

    // ---- 1. 筛选：计算机科学专业且成绩 > 80 ----
    std::vector<Student> cs_high;
    std::copy_if(students.begin(), students.end(), std::back_inserter(cs_high),
        [](const Student& s) {
            return s.major == "计算机科学" && s.score > 80;
        });

    std::cout << "\n===== 计算机科学，成绩 > 80 =====" << std::endl;
    for (const auto& s : cs_high) {
        std::cout << s.name << " | " << s.score << std::endl;
    }

    // ---- 2. 排序：先按专业，再按成绩降序 ----
    std::sort(students.begin(), students.end(),
        [](const Student& a, const Student& b) {
            if (a.major != b.major) return a.major < b.major;
            return a.score > b.score;
        });

    std::cout << "\n===== 按专业 + 成绩排序 =====" << std::endl;
    for (const auto& s : students) {
        std::cout << s.major << " | " << s.name << " | " << s.score << std::endl;
    }

    // ---- 3. 带上下文：统计某个专业的平均分 ----
    std::string target_major = "计算机科学";
    auto count = std::count_if(students.begin(), students.end(),
        [&target_major](const Student& s) {
            return s.major == target_major;
        });

    auto sum = std::accumulate(students.begin(), students.end(), 0,
        [&target_major](int acc, const Student& s) {
            return acc + (s.major == target_major ? s.score : 0);
        });

    std::cout << "\n" << target_major << " 专业:" << std::endl;
    std::cout << "  人数: " << count << std::endl;
    std::cout << "  平均分: " << (count > 0 ? sum / count : 0) << std::endl;

    return 0;
}

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

// 计算器工厂：返回不同的计算 Lambda
auto make_adder(int x) {
    // 值捕获 x —— 安全，x 的副本存在于闭包中
    return [x](int y) { return x + y; };
}

auto make_counter() {
    // 值捕获 counter 的副本 + mutable 使其可修改
    int counter = 0;
    return [counter]() mutable {
        return ++counter;
    };
}

// 危险：返回引用捕获局部变量的 Lambda
std::function<int()> make_dangerous_counter() {
    int counter = 0;
    return [&counter]() { return ++counter; };  // 悬挂引用！
}

int main() {
    std::cout << "===== 值捕获 =====" << std::endl;
    auto add5 = make_adder(5);
    std::cout << "add5(10) = " << add5(10) << std::endl;

    std::cout << "\n===== mutable 值捕获 =====" << std::endl;
    auto cnt = make_counter();
    std::cout << "第 1 次: " << cnt() << std::endl;
    std::cout << "第 2 次: " << cnt() << std::endl;
    std::cout << "第 3 次: " << cnt() << std::endl;
    // cnt 内部维护了独立的 counter 副本

    std::cout << "\n===== 引用捕获的陷阱 =====" << std::endl;
    // 在同一个作用域内，引用捕获是安全的
    int local = 100;
    auto ref_lambda = [&local]() { return local; };
    std::cout << "ref_lambda: " << ref_lambda() << std::endl;
    local = 200;
    std::cout << "修改后 ref_lambda: " << ref_lambda() << " ← 反映了变化" << std::endl;

    // 但离开作用域后引用捕获会悬空
    auto dangerous = make_dangerous_counter();
    // std::cout << dangerous() << std::endl;  // 未定义行为！

    std::cout << "\n===== 混合捕获 =====" << std::endl;
    int a = 10, b = 20, c = 30;
    // 默认值捕获，但 b 用引用捕获
    auto mixed = [=, &b]() {
        // a 和 c 是副本，b 是引用
        // a++;  // 编译错误：默认值捕获 + 非 mutable = 不可修改
        return a + b + c;
    };
    std::cout << "a + b + c = " << mixed() << std::endl;
    b = 999;
    std::cout << "修改 b 后: " << mixed() << " ← b 是引用" << std::endl;

    return 0;
}

#include <iostream>
#include <string>
#include <vector>

int main() {
    // C++14 泛型 Lambda：参数类型用 auto
    auto generic_add = [](auto a, auto b) { return a + b; };

    std::cout << "int + int:     " << generic_add(3, 4) << std::endl;
    std::cout << "double + int:  " << generic_add(3.14, 2) << std::endl;
    std::cout << "string:        "
              << generic_add(std::string("Hello, "), "World!") << std::endl;

    // 泛型 Lambda 配合 vector 数据累加
    std::vector<int> values = {1, 2, 3, 4, 5};
    auto sum = 0;
    auto fold = [&sum](const auto& container) {
        for (const auto& item : container) {
            sum += item;
        }
    };
    fold(values);
    std::cout << "累加结果: " << sum << std::endl;

    return 0;
}