C++ lambda 匿名函数深入解析

[capture-list] (parameter-list) mutable noexcept(optional) -> return-type { function-body }

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    // 使用 Lambda 表达式作为 std::sort 的比较准则
    // 按降序排序
    std::sort(v.begin(), v.end(), 
              [](int a, int b) { return a > b; } // Lambda 表达式
             );
    for (int i : v) {
        std::cout << i << " ";
    }
    // 输出: 9 6 5 4 3 2 1 1
    return 0;
}

int main() {
    int x = 10;
    int y = 20;
    // 值捕获：将 x 和 y 的当前值拷贝到 Lambda 中
    auto lambda_val = [x, y]() { 
        std::cout << "Inside lambda (by value): " << x << ", " << y << std::endl;
        // x++; // 错误！默认情况下，值捕获的变量是 const 的。
    };
    x = y = 100; // 修改外部变量
    lambda_val(); // 调用 Lambda
    // 输出: Inside lambda (by value): 10, 20
    return 0;
}

int main() {
    int x = 10;
    int y = 20;
    // 引用捕获：捕获 x 和 y 的引用
    auto lambda_ref = [&x, &y]() { 
        std::cout << "Inside lambda (by ref): " << x << ", " << y << std::endl;
        x++; y++; // 修改会影响外部变量
    };
    lambda_ref(); // 调用 Lambda
    std::cout << "After lambda: " << x << ", " << y << std::endl;
    // 输出: 
    // Inside lambda (by ref): 10, 20
    // After lambda: 11, 21
    return 0;
}

int a = 1, b = 2, c = 3;
// 隐式值捕获：自动捕获所有使用到的外部变量 (a, b)
auto lambda1 = [=]() { std::cout << a + b << std::endl; }; 
// 注意：c 没有被使用，所以不会被捕获
// 隐式引用捕获：自动捕获所有使用到的外部变量 (a, c)
auto lambda2 = [&]() { std::cout << a + c << std::endl; c = 100; }; 

int a = 1, b = 2, c = 3, d = 4;
// a 显式值捕获，b 显式引用捕获，其他使用到的变量按值捕获（但这里没有其他变量了）
auto lambda1 = [=, &b]() { /* a by value, b by ref */ };
// a 显式引用捕获，b 显式值捕获，其他使用到的变量按引用捕获（但这里没有其他变量了）
auto lambda2 = [&, b]() { /* a by ref, b by value */ };
// 错误！不能混合相同的捕获模式： [=, a] 或 [&, &b]

class MyClass {
public:
    void doSomething() {
        // 捕获 this，从而可以访问成员变量 value
        auto lambda = [this]() { 
            std::cout << "Value: " << value << std::endl; 
            memberFunction(); 
        };
        lambda();
    }
private:
    int value = 42;
    void memberFunction() { std::cout << "Member func called\n"; }
};

#include <vector>
#include <utility>  // for std::move
int main() {
    vector<int> v = {1, 2, 3};
    // 初始化捕获：将v移动到lambda内部的vec（避免拷贝大容器）
    auto func = [vec = move(v)] { 
        cout << "vec size: " << vec.size() << endl; 
    };
    func();  // 输出：vec size: 3
    // cout << v.size() << endl;  // 错误：v已被移动，处于无效状态
    return 0;
}

int main() {
    int count = 0;
    // 没有 mutable: 错误！不能修改值捕获的变量。
    // auto lambda = [count]() { count++; }; 
    // 使用 mutable
    auto lambda = [count]() mutable { 
        count++; // 现在可以修改了
        std::cout << "Count inside lambda: " << count << std::endl;
    };
    lambda(); // 输出: Count inside lambda: 1
    lambda(); // 输出: Count inside lambda: 2
    std::cout << "Count outside: " << count << std::endl; // 输出: Count outside: 0
    // 注意：修改的是 Lambda 内部的副本，不影响外部变量。
    return 0;
}

std::vector<int> numbers = {1, 2, 3, 4, 5};
// 编译器自动推导返回类型为 bool
auto is_even = [](int n) { return n % 2 == 0; };
// 显式指定返回类型为 double (使用尾置返回类型语法)
auto divide = [](int a, int b) -> double {
    if (b == 0) {
        return 0.0; // 返回 double
    }
    return static_cast<double>(a) / b; // 返回 double
};

std::vector<int> vec = {5, 3, 8, 1, 9};
// 计算大于 5 的元素数量
int count = std::count_if(vec.begin(), vec.end(), 
                         [](int n) { return n > 5; });
// 将所有元素翻倍
std::for_each(vec.begin(), vec.end(), 
             [](int& n) { n *= 2; }); // 注意：需要引用才能修改原值
vector<int> nums = {3, 1, 4, 1, 5, 9};
// 用lambda作为sort的比较函数（降序排序）
sort(nums.begin(), nums.end(), [](int a, int b) { 
    return a > b; 
});  // nums变为：9,5,4,3,1,1
// 用lambda作为find_if的条件（查找偶数）
auto it = find_if(nums.begin(), nums.end(), [](int x) { 
    return x % 2 == 0; 
});
if (it != nums.end()) {
    cout << "找到偶数：" << *it << endl;  // 输出：4
}

#include <thread>
#include <future>
int main() {
    // 线程任务用lambda定义
    thread t([] { 
        cout << "线程执行中..." << endl; 
    });
    t.join();
    // 异步任务用lambda定义
    future<int> fut = async([] { 
        return 1 + 2; 
    });
    cout << "异步结果：" << fut.get() << endl;  // 输出：3
    return 0;
}

std::map<std::string, int> name_age;
// 按值（年龄）排序，而不是键（名字）
std::vector<std::pair<std::string, int>> vec(name_age.begin(), name_age.end());
std::sort(vec.begin(), vec.end(),
         [](const auto& a, const auto& b) { return a.second < b.second; });