C++如何向Lambda传递参数与捕获

// 原比较函数
bool isShorter(const string &a, const string &b) {
    return a.size() < b.size();
}
// 用Lambda实现相同功能
vector<string> words = {"apple", "banana", "cherry", "date"};
stable_sort(words.begin(), words.end(), 
            [](const string &a, const string &b) { 
                return a.size() < b.size(); 
            });

#include <vector>
#include <string>
#include <algorithm>
// 过滤字符串向量，找到第一个长度大于或等于指定大小的字符串
std::vector<std::string>::const_iterator filterWords(const std::vector<std::string> &words, size_t sz) {
    // 捕获 sz，按值传递（隐式拷贝），用于查找第一个长度 >= sz 的字符串
    auto it = std::find_if(words.begin(), words.end(),
                           [sz](const std::string &s) { 
                               return s.size() >= sz; 
                           });
    return it; // 返回找到的字符串的迭代器
}
int main() {
    std::vector<std::string> words = {"apple", "banana", "cherry", "date"};
    size_t sz = 6;
    auto result = filterWords(words, sz);
    if (result != words.end()) {
        std::cout << "找到第一个长度 >= " << sz << " 的字符串: " << *result << std::endl;
    } else {
        std::cout << "未找到长度 >= " << sz << " 的字符串。" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
/**
 * @brief 主函数，程序的入口点。
 * 
 * 该函数创建一个整数向量，使用 std::count_if 统计向量中偶数的数量，并输出结果。
 * 
 * @return int 程序的退出状态码，0 表示正常退出。
 */
int main() {
    // 定义一个整数向量 nums，并初始化其元素
    std::vector<int> nums = {1, 2, 3, 4};
    // 定义一个变量 count，用于存储偶数的数量，初始化为 0
    int count = 0;
    // 使用 std::count_if 统计向量中偶数的数量
    // std::count_if 接受三个参数：向量的起始迭代器、结束迭代器和一个谓词函数
    // 谓词函数是一个 lambda 表达式，用于判断元素是否为偶数
    count = std::count_if(nums.begin(), nums.end(), [&count](int x) {
        // 判断元素 x 是否为偶数
        return x % 2 == 0;
    });
    // 输出偶数的数量
    std::cout << count << std::endl; // 输出2（统计偶数的数量）
    // 返回 0 表示程序正常结束
    return 0;
}

int threshold = 5;
vector<int> data = {3, 7, 2, 8};
// 隐式按值捕获所有外部变量（此处只有threshold）
auto result = count_if(data.begin(), data.end(),
                      [=](int x) { 
                          return x > threshold; 
                      });
cout << result; // 输出2（7和8大于5）

int base = 10;
double factor = 1.5;
vector<int> values = {3, 5, 7};
// 按引用捕获base，按值捕获其他变量
for_each(values.begin(), values.end(),
        [&base, factor](int &x) {
            x = base + x * factor; 
        });
// 结果：base=10 → 10+3 * 1.5=14.5 → 转为int为14
// 最终values变为[14, 17, 20]

#include<iostream>
// 引入输入输出流库，使得程序可以使用 std::cout 进行输出操作
using namespace std;
// 使用标准命名空间，这样可以直接使用标准库中的对象和函数，而无需加 std:: 前缀
auto createLambda() {
    // 定义一个函数 createLambda，使用 auto 让编译器自动推导返回类型
    int localVar = 42;
    // 在函数内部定义一个局部变量 localVar，并初始化为 42
    return [&localVar] { return localVar; }; 
    // 返回一个 lambda 表达式，该 lambda 表达式通过值捕获了局部变量 localVar
}
int main() {
    // 程序的入口函数
    auto lambda = createLambda();
    // 调用 createLambda 函数，将返回的 lambda 表达式赋值给变量 lambda
    cout << lambda(); 
    // 调用 lambda 表达式，由于 lambda 表达式通过值捕获了 localVar 的副本，所以可以正常输出 42
    return 0;
    // 程序正常结束，返回 0
}

#include<iostream>
// 引入输入输出流库，使得程序可以使用 std::cout 进行输出操作
using namespace std;
// 使用标准命名空间，这样可以直接使用标准库中的对象和函数，而无需加 std:: 前缀
auto createLambda() {
    // 定义一个函数 createLambda，使用 auto 让编译器自动推导返回类型
    int localVar = 42;
    // 在函数内部定义一个局部变量 localVar，并初始化为 42
    return [localVar] { return localVar; }; 
    // 返回一个 lambda 表达式，该 lambda 表达式通过值捕获了局部变量 localVar
    // 值捕获会在创建 lambda 表达式时复制一份 localVar 的副本，即使原变量被销毁，副本仍然有效
}
int main() {
    // 程序的入口函数
    auto lambda = createLambda();
    // 调用 createLambda 函数，将返回的 lambda 表达式赋值给变量 lambda
    cout << lambda(); 
    // 调用 lambda 表达式，由于 lambda 表达式通过值捕获了 localVar 的副本，所以可以正常输出 42
    return 0;
    // 程序正常结束，返回 0
}

int x = 10;
auto lambda = [x] { 
    x++; // 编译错误：按值捕获的变量不可修改
};

auto lambda = [x]() mutable { 
    x++; // 修改的是副本，不影响外部x
};

class Processor {
private:
    int offset;
public:
    void process(vector<int> &data) {
        for_each(data.begin(), data.end(),
                [this](int &x) { x += offset; }); // 正确捕获this
    }
};