// 原比較函數(shù)
bool isShorter(const string &a, const string &b) {
    return a.size() < b.size();
}
// 用Lambda實現(xiàn)相同功能
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 主函數(shù)，程序的入口點。
 * 
 * 該函數(shù)創(chuàng)建一個整數(shù)向量，使用 std::count_if 統(tǒng)計向量中偶數(shù)的數(shù)量，并輸出結(jié)果。
 * 
 * @return int 程序的退出狀態(tài)碼，0 表示正常退出。
 */
int main() {
    // 定義一個整數(shù)向量 nums，并初始化其元素
    std::vector<int> nums = {1, 2, 3, 4};
    // 定義一個變量 count，用于存儲偶數(shù)的數(shù)量，初始化為 0
    int count = 0;
    // 使用 std::count_if 統(tǒng)計向量中偶數(shù)的數(shù)量
    // std::count_if 接受三個參數(shù)：向量的起始迭代器、結(jié)束迭代器和一個謂詞函數(shù)
    // 謂詞函數(shù)是一個 lambda 表達式，用于判斷元素是否為偶數(shù)
    count = std::count_if(nums.begin(), nums.end(), [&count](int x) {
        // 判斷元素 x 是否為偶數(shù)
        return x % 2 == 0;
    });
    // 輸出偶數(shù)的數(shù)量
    std::cout << count << std::endl; // 輸出2（統(tǒng)計偶數(shù)的數(shù)量）
    // 返回 0 表示程序正常結(jié)束
    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; 
        });
// 結(jié)果：base=10 → 10+3 * 1.5=14.5 → 轉(zhuǎn)為int為14
// 最終values變?yōu)閇14, 17, 20]

#include<iostream>
// 引入輸入輸出流庫，使得程序可以使用 std::cout 進行輸出操作
using namespace std;
// 使用標準命名空間，這樣可以直接使用標準庫中的對象和函數(shù)，而無需加 std:: 前綴
auto createLambda() {
    // 定義一個函數(shù) createLambda，使用 auto 讓編譯器自動推導返回類型
    int localVar = 42;
    // 在函數(shù)內(nèi)部定義一個局部變量 localVar，并初始化為 42
    return [&localVar] { return localVar; }; 
    // 返回一個 lambda 表達式，該 lambda 表達式通過值捕獲了局部變量 localVar
}
int main() {
    // 程序的入口函數(shù)
    auto lambda = createLambda();
    // 調(diào)用 createLambda 函數(shù)，將返回的 lambda 表達式賦值給變量 lambda
    cout << lambda(); 
    // 調(diào)用 lambda 表達式，由于 lambda 表達式通過值捕獲了 localVar 的副本，所以可以正常輸出 42
    return 0;
    // 程序正常結(jié)束，返回 0
}

#include<iostream>
// 引入輸入輸出流庫，使得程序可以使用 std::cout 進行輸出操作
using namespace std;
// 使用標準命名空間，這樣可以直接使用標準庫中的對象和函數(shù)，而無需加 std:: 前綴
auto createLambda() {
    // 定義一個函數(shù) createLambda，使用 auto 讓編譯器自動推導返回類型
    int localVar = 42;
    // 在函數(shù)內(nèi)部定義一個局部變量 localVar，并初始化為 42
    return [localVar] { return localVar; }; 
    // 返回一個 lambda 表達式，該 lambda 表達式通過值捕獲了局部變量 localVar
    // 值捕獲會在創(chuàng)建 lambda 表達式時復制一份 localVar 的副本，即使原變量被銷毀，副本仍然有效
}
int main() {
    // 程序的入口函數(shù)
    auto lambda = createLambda();
    // 調(diào)用 createLambda 函數(shù)，將返回的 lambda 表達式賦值給變量 lambda
    cout << lambda(); 
    // 調(diào)用 lambda 表達式，由于 lambda 表達式通過值捕獲了 localVar 的副本，所以可以正常輸出 42
    return 0;
    // 程序正常結(jié)束，返回 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
    }
};