STL算法与工具

// 版本1：使用默认 operator< 进行升序排序
template <class RandomIt>
void sort(RandomIt first, RandomIt last);
 
// 版本2：使用自定义比较函数/函数对象
template <class RandomIt, class Compare>
void sort(RandomIt first, RandomIt last, Compare comp);

#include <iostream>     // 标准输入输出
#include <vector>       // vector 容器
#include <algorithm>    // sort 算法
#include <functional>   // greater<> 函数对象
 
int main() {
    // 创建一个包含无序整数的 vector
    std::vector<int> nums = {5, 2, 8, 1, 9, 3, 7};
 
    // ========== 升序排序（默认行为）==========
    // sort 使用 operator< 比较元素，将最小值放在前面
    std::sort(nums.begin(), nums.end());
 
    std::cout << "升序: ";
    for (int n : nums) {          // 范围 for 循环遍历
        std::cout << n << " ";    // 输出：1 2 3 5 7 8 9
    }
    std::cout << std::endl;
 
    // ========== 降序排序（传入比较器）==========
    // std::greater<int>() 是一个函数对象，实现 a > b 的比较逻辑
    // 当 a > b 返回 true 时，a 排在 b 前面，即降序
    std::sort(nums.begin(), nums.end(), std::greater<int>());
 
    std::cout << "降序: ";
    for (int n : nums) {          // 遍历排序后的结果
        std::cout << n << " ";    // 输出：9 8 7 5 3 2 1
    }
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <algorithm>    // sort
 
int main() {
    int arr[] = {42, 17, 8, 55, 3};       // C 风格数组
    int n = sizeof(arr) / sizeof(arr[0]);  // 计算数组元素个数：5
 
    // arr 退化为指向首元素的指针 (int*)
    // arr + n 指向数组末尾的下一个位置（past-the-end）
    std::sort(arr, arr + n);
 
    for (int i = 0; i < n; ++i) {   // 传统 for 循环遍历
        std::cout << arr[i] << " "; // 输出：3 8 17 42 55
    }
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
 
// 定义一个学生结构体
struct Student {
    std::string name;   // 姓名
    int score;          // 分数
};
 
int main() {
    // 初始化学生列表
    std::vector<Student> students = {
        {"Alice", 88},
        {"Bob",   95},
        {"Carol", 72},
        {"Dave",  95}
    };
 
    // 使用 Lambda 表达式作为比较器
    // 规则：先按分数降序；分数相同时，按姓名字典序升序
    std::sort(students.begin(), students.end(),
        [](const Student& a, const Student& b) {  // Lambda 接受两个 const 引用
            if (a.score != b.score)                // 如果分数不同
                return a.score > b.score;          // 分数高的排前面（降序）
            return a.name < b.name;                // 分数相同，按姓名升序
        }
    );
 
    // 输出排序结果
    for (const auto& s : students) {               // const 引用避免拷贝
        std::cout << s.name << ": " << s.score << std::endl;
    }
    // 输出：
    // Bob: 95
    // Dave: 95
    // Alice: 88
    // Carol: 72
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    std::vector<int> v = {9, 4, 7, 2, 5, 1, 8, 3, 6};
 
    // ========== partial_sort ==========
    // 只让前 3 个位置放最小的 3 个元素（排好序），其余元素顺序未定义
    std::partial_sort(v.begin(), v.begin() + 3, v.end());
    // v 现在可能是：{1, 2, 3, 9, 5, 4, 8, 7, 6}
    // 只保证 v[0]~v[2] 是排好序的最小 3 个
 
    std::cout << "partial_sort 前3: ";
    for (int x : v) std::cout << x << " ";   // 前三位一定是 1 2 3
    std::cout << std::endl;
 
    // ========== nth_element ==========
    v = {9, 4, 7, 2, 5, 1, 8, 3, 6};
    // 将第 4 小的元素（下标 3）放到正确位置
    // 它左边的都 <= 它，右边的都 >= 它，但各自内部不保证有序
    std::nth_element(v.begin(), v.begin() + 3, v.end());
 
    std::cout << "第4小的元素: " << v[3] << std::endl;  // 输出 4
 
    return 0;
}

// 精确查找：使用 operator== 比较
template <class InputIt, class T>
InputIt find(InputIt first, InputIt last, const T& value);
 
// 条件查找：使用谓词 (Predicate)
template <class InputIt, class UnaryPredicate>
InputIt find_if(InputIt first, InputIt last, UnaryPredicate pred);
 
// 否定条件查找 (C++11)：找第一个使谓词返回 false 的元素
template <class InputIt, class UnaryPredicate>
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate pred);

#include <iostream>
#include <vector>
#include <algorithm>    // find, find_if, find_if_not
 
int main() {
    std::vector<int> nums = {10, 20, 30, 40, 50};
 
    // ========== std::find：精确匹配 ==========
    auto it = std::find(nums.begin(), nums.end(), 30);  // 查找值为 30 的元素
 
    if (it != nums.end()) {                              // 判断是否找到
        // std::distance 计算两个迭代器之间的距离（即下标）
        std::cout << "找到 30，下标: "
                  << std::distance(nums.begin(), it)     // 输出：2
                  << std::endl;
    } else {
        std::cout << "未找到" << std::endl;
    }
 
    // ========== std::find_if：条件查找 ==========
    // 查找第一个大于 25 的元素
    auto it2 = std::find_if(nums.begin(), nums.end(),
        [](int x) {             // Lambda 谓词（Predicate）
            return x > 25;      // 条件：元素值 > 25
        }
    );
 
    if (it2 != nums.end()) {
        std::cout << "第一个 > 25 的元素: " << *it2 << std::endl;  // 输出：30
    }
 
    // ========== std::find_if_not：否定条件查找 ==========
    // 查找第一个 "不小于 30" 的元素（即 >= 30）
    auto it3 = std::find_if_not(nums.begin(), nums.end(),
        [](int x) {
            return x < 30;      // 谓词：x < 30
        }                       // find_if_not 找第一个使此谓词返回 false 的
    );
 
    if (it3 != nums.end()) {
        std::cout << "第一个 >= 30 的元素: " << *it3 << std::endl; // 输出：30
    }
 
    return 0;
}

#include <iostream>
#include <string>
#include <algorithm>
 
int main() {
    std::string str = "Hello, World!";
 
    // 查找第一个逗号
    auto it = std::find(str.begin(), str.end(), ',');
 
    if (it != str.end()) {
        // 计算逗号的位置（下标）
        size_t pos = std::distance(str.begin(), it);
        std::cout << "逗号位于下标: " << pos << std::endl;  // 输出：5
 
        // 利用迭代器范围提取子串：从开头到逗号之前
        std::string before_comma(str.begin(), it);  // 用迭代器范围构造新字符串
        std::cout << "逗号前内容: " << before_comma << std::endl;  // 输出：Hello
    }
 
    return 0;
}

template <class InputIt, class UnaryFunction>
UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f);

#include <iostream>
#include <vector>
#include <algorithm>    // for_each
 
// 普通函数：打印元素并换行
void printElement(int x) {
    std::cout << "[" << x << "] ";   // 格式化输出每个元素
}
 
int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
 
    // ========== 方式1：传入普通函数指针 ==========
    std::cout << "函数指针: ";
    std::for_each(nums.begin(), nums.end(), printElement);
    // 输出：[1] [2] [3] [4] [5]
    std::cout << std::endl;
 
    // ========== 方式2：传入 Lambda 表达式 ==========
    std::cout << "Lambda:   ";
    std::for_each(nums.begin(), nums.end(),
        [](int x) {                           // Lambda：匿名函数
            std::cout << x * x << " ";        // 输出每个元素的平方
        }
    );
    // 输出：1 4 9 16 25
    std::cout << std::endl;
 
    // ========== 方式3：修改元素（通过引用）==========
    // Lambda 参数使用引用 (int&)，可以直接修改原容器中的元素
    std::for_each(nums.begin(), nums.end(),
        [](int& x) {                          // 注意：int& 引用
            x *= 2;                           // 每个元素翻倍
        }
    );
 
    std::cout << "翻倍后:   ";
    for (int n : nums) std::cout << n << " "; // 输出：2 4 6 8 10
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
 
// 一个有状态的函数对象（Functor）
struct Accumulator {
    int sum = 0;       // 内部状态：累加和
    int count = 0;     // 内部状态：计数
 
    // 重载 operator()，使对象可以像函数一样被调用
    void operator()(int x) {
        sum += x;      // 累加当前元素
        ++count;       // 计数 +1
    }
};
 
int main() {
    std::vector<int> data = {10, 20, 30, 40, 50};
 
    // for_each 返回函数对象的副本，包含遍历后的最终状态
    Accumulator result = std::for_each(data.begin(), data.end(), Accumulator());
 
    std::cout << "总和: " << result.sum << std::endl;       // 输出：150
    std::cout << "个数: " << result.count << std::endl;     // 输出：5
    std::cout << "均值: " << static_cast<double>(result.sum) / result.count
              << std::endl;                                  // 输出：30
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    // 只对下标 [2, 7)（即第 3~7 个元素）执行操作
    // 范围 for 做不到这一点（除非手动加 if 判断，但很不优雅）
    std::for_each(v.begin() + 2, v.begin() + 7,
        [](int& x) {
            x = 0;    // 将这个子范围内的元素清零
        }
    );
 
    for (int n : v) std::cout << n << " ";
    // 输出：1 2 0 0 0 0 0 8 9 10
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>    // for_each_n (C++17)
 
int main() {
    std::vector<int> v = {10, 20, 30, 40, 50};
 
    // 只对前 3 个元素执行操作
    std::for_each_n(v.begin(), 3,
        [](int& x) {
            x += 100;      // 前 3 个元素各加 100
        }
    );
 
    for (int n : v) std::cout << n << " ";
    // 输出：110 120 130 40 50
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    std::vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    
    std::sort(v.begin(), v.begin() + 4);
    
    auto it = std::find(v.begin(), v.end(), 5);
    
    std::cout << std::distance(v.begin(), it) << std::endl;
    
    return 0;
}

template <class T1, class T2>
struct pair {
    T1 first;   // 第一个元素
    T2 second;  // 第二个元素
};

#include <utility>  // pair 所在头文件
#include <string>
#include <iostream>
 
int main() {
    // ① 直接构造：显式指定模板参数
    std::pair<int, std::string> p1(1, "Alice");
 
    // ② 使用 std::make_pair —— 自动推导模板参数（C++11 前最常用）
    auto p2 = std::make_pair(2, "Bob");
    // 编译器自动推导为 pair<int, const char*>
 
    // ③ C++11 列表初始化
    std::pair<double, int> p3 = {3.14, 42};
 
    // ④ C++17 类模板参数推导 (CTAD)
    // 无需写模板参数，编译器从构造函数参数推导
    std::pair p4(100, 200);  // 推导为 pair<int, int>
 
    // 访问成员
    std::cout << p1.first << ", " << p1.second << std::endl;
    // 输出: 1, Alice
 
    return 0;
}

#include <utility>
#include <iostream>
#include <vector>
#include <algorithm>  // sort
 
int main() {
    std::vector<std::pair<int, int>> vec = {
        {3, 1},   // 第一个 pair
        {1, 5},   // 第二个 pair
        {3, 0},   // 第三个 pair
        {1, 2}    // 第四个 pair
    };
 
    // 默认按字典序排序: 先按 first 升序，first 相同则按 second 升序
    std::sort(vec.begin(), vec.end());
 
    for (const auto& p : vec) {           // 范围 for 遍历
        std::cout << "(" << p.first       // 输出 first
                  << ", " << p.second     // 输出 second
                  << ")" << std::endl;
    }
    // 输出:
    // (1, 2)
    // (1, 5)
    // (3, 0)
    // (3, 1)
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
int main() {
    std::map<std::string, int> scores;  // 创建一个 string->int 的映射
    scores["Alice"] = 95;               // 插入键值对
    scores["Bob"]   = 87;               // 插入键值对
 
    // 遍历 map：it->first 是 key，it->second 是 value
    for (const auto& elem : scores) {
        // elem 的类型是 const std::pair<const std::string, int>&
        std::cout << elem.first         // 输出键 (name)
                  << ": "
                  << elem.second        // 输出值 (score)
                  << std::endl;
    }
 
    return 0;
}

#include <set>
#include <iostream>
 
int main() {
    std::set<int> s = {1, 2, 3};           // 初始化集合
 
    auto result = s.insert(4);             // 尝试插入 4
    // result 类型: std::pair<std::set<int>::iterator, bool>
 
    if (result.second) {                   // second == true 表示插入成功
        std::cout << "插入成功: "
                  << *result.first         // first 指向新插入的元素
                  << std::endl;
    }
 
    auto result2 = s.insert(2);            // 尝试插入已存在的 2
    if (!result2.second) {                 // second == false 表示元素已存在
        std::cout << "元素已存在: "
                  << *result2.first        // first 指向已有的元素
                  << std::endl;
    }
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
int main() {
    std::map<std::string, int> scores = {  // 初始化 map
        {"Alice", 95},
        {"Bob", 87}
    };
 
    // C++17 结构化绑定: 将 pair 拆分为 name 和 score
    for (const auto& [name, score] : scores) {
        std::cout << name << ": " << score << std::endl;
        // 不再需要 .first / .second，代码可读性大幅提升
    }
 
    // 也可用于 insert 的返回值
    auto [iter, success] = scores.insert({"Charlie", 77});
    // iter  -> 迭代器
    // success -> bool，是否插入成功
 
    if (success) {
        std::cout << "插入: " << iter->first << std::endl;
    }
 
    return 0;
}

// tuple 的概念模型（非实际实现）
template <class... Types>
class tuple;  // 可变参数模板（variadic template）

#include <tuple>
#include <string>
#include <iostream>
 
int main() {
    // ① 直接构造
    std::tuple<int, double, std::string> t1(1, 3.14, "Hello");
 
    // ② 使用 std::make_tuple —— 自动推导类型
    auto t2 = std::make_tuple(42, 2.718, std::string("World"));
 
    // ③ C++17 CTAD
    std::tuple t3(100, 'A', 3.14f);
    // 推导为 tuple<int, char, float>
 
    return 0;
}

#include <tuple>
#include <string>
#include <iostream>
 
int main() {
    auto student = std::make_tuple(
        std::string("Alice"),  // 索引 0: 姓名
        20,                    // 索引 1: 年龄
        3.95                   // 索引 2: GPA
    );
 
    // 使用 std::get<索引> 访问元素（索引从 0 开始）
    std::cout << "姓名: " << std::get<0>(student) << std::endl;  // Alice
    std::cout << "年龄: " << std::get<1>(student) << std::endl;  // 20
    std::cout << "GPA:  " << std::get<2>(student) << std::endl;  // 3.95
 
    // 修改元素（get 返回引用）
    std::get<1>(student) = 21;   // 将年龄改为 21
 
    // C++14: 按类型访问（前提：类型在 tuple 中唯一）
    std::cout << "姓名: " << std::get<std::string>(student) << std::endl;
    // 若 tuple 中有两个 string，则编译报错（ambiguous）
 
    return 0;
}

#include <tuple>
#include <iostream>
#include <string>
 
int main() {
    auto t = std::make_tuple(1, 3.14, std::string("Hi"));
 
    // ① std::tuple_size: 获取 tuple 中元素个数（编译期）
    constexpr size_t sz = std::tuple_size<decltype(t)>::value;
    std::cout << "元素个数: " << sz << std::endl;  // 输出: 3
 
    // ② std::tuple_element: 获取第 N 个元素的类型（编译期）
    // tuple_element<0, decltype(t)>::type  →  int
    // tuple_element<1, decltype(t)>::type  →  double
    // tuple_element<2, decltype(t)>::type  →  std::string
 
    // ③ std::tie: 将 tuple 解包到已有变量
    int    a;        // 用于接收第 0 个元素
    double b;        // 用于接收第 1 个元素
    std::string c;   // 用于接收第 2 个元素
    std::tie(a, b, c) = t;  // 解包: a=1, b=3.14, c="Hi"
    std::cout << a << ", " << b << ", " << c << std::endl;
 
    // ④ std::ignore: 忽略不关心的元素
    int x;
    std::tie(x, std::ignore, std::ignore) = t;
    // 只取第一个元素，其余忽略
    std::cout << "只取第一个: " << x << std::endl;
 
    // ⑤ std::tuple_cat: 拼接多个 tuple
    auto t1 = std::make_tuple(1, 2);           // tuple<int, int>
    auto t2 = std::make_tuple(3.0, "four");    // tuple<double, const char*>
    auto t3 = std::tuple_cat(t1, t2);          // tuple<int, int, double, const char*>
    std::cout << std::get<3>(t3) << std::endl;  // 输出: four
 
    return 0;
}

// C++17 结构化绑定：比 std::tie 更简洁
auto [name, age, gpa] = std::make_tuple(
    std::string("Alice"), 20, 3.95
);
// name = "Alice", age = 20, gpa = 3.95

#include <tuple>
#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
 
struct Student {
    std::string name;   // 姓名
    int age;            // 年龄
    double gpa;         // 绩点
 
    // 利用 std::tie 实现 < 运算符
    // 比较优先级: age -> gpa -> name（字典序）
    bool operator<(const Student& other) const {
        // tie 创建引用 tuple，直接利用 tuple 的字典序比较
        return std::tie(age, gpa, name)
             < std::tie(other.age, other.gpa, other.name);
    }
};
 
int main() {
    std::vector<Student> students = {
        {"Charlie", 21, 3.5},   // 学生 1
        {"Alice",   20, 3.9},   // 学生 2
        {"Bob",     20, 3.9},   // 学生 3
        {"Diana",   20, 3.5}    // 学生 4
    };
 
    std::sort(students.begin(), students.end());  // 使用自定义 operator
 
    for (const auto& s : students) {
        std::cout << s.name << " (age=" << s.age
                  << ", gpa=" << s.gpa << ")" << std::endl;
    }
    // 输出 (先按 age，再按 gpa，最后按 name):
    // Diana (age=20, gpa=3.5)
    // Alice (age=20, gpa=3.9)
    // Bob   (age=20, gpa=3.9)
    // Charlie (age=21, gpa=3.5)
 
    return 0;
}

// std::pair<int, double> 的内存布局（可能有 padding）
// 假设 int=4字节, double=8字节, 对齐要求
//
// 地址偏移:  [0]    [4]      [8]              [16]
//            |--int--|--pad---|----double-------|
//             first           second
//
// sizeof(pair<int,double>) 通常 = 16（因为 double 要求 8 字节对齐）
 
// std::tuple<int, double, char> 的内存布局
// 注意：tuple 的存储顺序可能与声明顺序不同（实现相关）
// 某些实现会倒序存储以优化对齐
//
// 可能的布局:
// 地址偏移:  [0]         [8]    [12] [13]   [16]
//            |--double---|--int--|char|--pad--|
//             (idx 1)    (idx 0) (idx 2)
//
// sizeof(tuple<int, double, char>) 通常 = 16（经过对齐优化）

#include <tuple>
#include <string>
#include <iostream>
#include <cmath>
 
// 场景: 解一元二次方程 ax^2 + bx + c = 0
// 返回: (是否有实数根, 根1, 根2)
std::tuple<bool, double, double> solveQuadratic(
    double a, double b, double c)
{
    double discriminant = b * b - 4 * a * c;   // 计算判别式
 
    if (discriminant < 0) {
        return {false, 0.0, 0.0};              // 无实数根
    }
 
    double sqrtD = std::sqrt(discriminant);    // 判别式开方
    double x1 = (-b + sqrtD) / (2 * a);       // 根1
    double x2 = (-b - sqrtD) / (2 * a);       // 根2
    return {true, x1, x2};                    // 返回结果
}
 
int main() {
    // C++17 结构化绑定接收返回值
    auto [hasRoot, r1, r2] = solveQuadratic(1, -3, 2);
 
    if (hasRoot) {
        std::cout << "根: x1=" << r1            // 输出根1
                  << ", x2=" << r2 << std::endl; // 输出根2
        // 输出: 根: x1=2, x2=1
    } else {
        std::cout << "无实数根" << std::endl;
    }
 
    return 0;
}

#include <tuple>
#include <iostream>
#include <string>
 
int main() {
    auto t1 = std::make_tuple(1, 2, 3);
    auto t2 = std::make_tuple(1, 2, 4);
    auto t3 = std::make_tuple(1, 2, 3);
 
    std::cout << (t1 < t2) << " "
              << (t1 == t3) << " "
              << std::tuple_size<decltype(t1)>::value
              << std::endl;
    return 0;
}

#include <iostream>
 
// 定义一个函数对象类
struct Greeter {
    // 重载函数调用运算符 operator()
    void operator()(const std::string& name) const {
        std::cout << "Hello, " << name << "!" << std::endl; // 像函数一样执行逻辑
    }
};
 
int main() {
    Greeter greet;          // 创建一个 Greeter 类型的对象（这就是 functor）
    greet("World");         // 调用 operator()，输出: Hello, World!
    greet("C++ Learner");   // 再次调用，输出: Hello, C++ Learner!
 
    Greeter()("Temp");      // 也可以用匿名临时对象直接调用
 
    return 0;
}

#include <iostream>
 
// ========== 方式一：普通函数 ==========
// 普通函数没有自己的"记忆"，无法在调用之间保持状态
bool is_greater_than_5(int x) {
    return x > 5;   // 阈值 5 被硬编码，无法灵活修改
}
 
// ========== 方式二：函数对象 ==========
// 函数对象可以携带状态（成员变量），极其灵活
struct IsGreaterThan {
    int threshold;   // 成员变量：存储阈值，这就是"状态"
 
    // 构造函数：在创建对象时设定阈值
    IsGreaterThan(int t) : threshold(t) {}
 
    // 重载 operator()：使用存储的阈值进行比较
    bool operator()(int x) const {
        return x > threshold;  // 阈值来自成员变量，完全可配置
    }
};
 
int main() {
    IsGreaterThan gt10(10);   // 创建一个"大于10"的判断器
    IsGreaterThan gt100(100); // 创建一个"大于100"的判断器
 
    std::cout << gt10(15)  << std::endl;  // 输出 1 (true)，15 > 10
    std::cout << gt10(5)   << std::endl;  // 输出 0 (false)，5 > 10 不成立
    std::cout << gt100(50) << std::endl;  // 输出 0 (false)，50 > 100 不成立
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm> // std::for_each
 
// 一个有状态的函数对象：调用计数器
struct CallCounter {
    int count;   // 状态：记录被调用的次数
 
    // 构造函数：初始化计数为 0
    CallCounter() : count(0) {}
 
    // 每次被调用时，计数器自增，并打印当前元素
    void operator()(int x) {
        ++count;                                       // 状态更新：计数 +1
        std::cout << "第 " << count << " 次调用，值: " << x << std::endl;
    }
};
 
int main() {
    std::vector<int> nums = {10, 20, 30, 40, 50};
 
    // ⚠️ 重要细节：std::for_each 会【拷贝】传入的函数对象
    // 它返回的是内部使用的那份拷贝（已累积了状态）
    CallCounter result = std::for_each(nums.begin(), nums.end(), CallCounter());
 
    // 通过返回值获取最终状态
    std::cout << "总共调用了 " << result.count << " 次" << std::endl; // 输出: 5
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>   // std::sort, std::transform
#include <functional>  // STL 内置函数对象的头文件
 
int main() {
    std::vector<int> v = {5, 2, 8, 1, 9, 3};
 
    // ========== 比较类函数对象 ==========
    // std::greater<int>() 创建一个"大于"比较器的临时对象
    // 等价于传入一个 bool cmp(int a, int b) { return a > b; } 的函数
    std::sort(v.begin(), v.end(), std::greater<int>()); // 降序排列
    // 排序结果: 9, 8, 5, 3, 2, 1
 
    for (int x : v) std::cout << x << " ";  // 输出: 9 8 5 3 2 1
    std::cout << std::endl;
 
    // ========== 算术类函数对象 ==========
    std::vector<int> a = {1, 2, 3, 4};
    std::vector<int> b = {10, 20, 30, 40};
    std::vector<int> result(4);  // 存放结果的容器，预留空间
 
    // std::plus<int>() 创建一个"加法"函数对象
    // transform 对 a 和 b 的对应元素执行 plus，结果写入 result
    std::transform(a.begin(), a.end(),     // 第一个输入范围
                   b.begin(),              // 第二个输入范围的起始
                   result.begin(),         // 输出范围的起始
                   std::plus<int>());      // 二元操作：加法
 
    for (int x : result) std::cout << x << " ";  // 输出: 11 22 33 44
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
 
// 实际场景：一个可配置的字符串过滤器
struct StringFilter {
    size_t min_length;       // 最小长度阈值
    std::string must_contain; // 必须包含的子串
    bool case_sensitive;     // 是否区分大小写
 
    // 构造函数：接收所有配置参数
    StringFilter(size_t len, const std::string& substr, bool cs = true)
        : min_length(len)          // 初始化最小长度
        , must_contain(substr)     // 初始化必须包含的子串
        , case_sensitive(cs) {}    // 初始化大小写敏感标志
 
    // operator()：执行过滤逻辑，返回是否通过筛选
    bool operator()(const std::string& s) const {
        // 条件1：长度必须达标
        if (s.length() < min_length) return false;
 
        // 条件2：必须包含指定子串
        if (case_sensitive) {
            return s.find(must_contain) != std::string::npos;  // 精确查找
        } else {
            // 不区分大小写时，先将两者都转成小写再比较
            std::string lower_s = s;           // 拷贝原始字符串
            std::string lower_sub = must_contain; // 拷贝子串
            // 将字符串转为小写
            std::transform(lower_s.begin(), lower_s.end(),
                           lower_s.begin(), ::tolower);
            std::transform(lower_sub.begin(), lower_sub.end(),
                           lower_sub.begin(), ::tolower);
            return lower_s.find(lower_sub) != std::string::npos; // 小写后查找
        }
    }
};
 
int main() {
    std::vector<std::string> words = {
        "Hello", "C++", "Programming", "cpp", "Hi", "Computer"
    };
 
    // 创建过滤器：长度 >= 3，必须包含 "c"，不区分大小写
    StringFilter filter(3, "c", false);
 
    // 使用 std::count_if 统计满足条件的元素数量
    int count = std::count_if(words.begin(), words.end(), filter);
    std::cout << "满足条件的单词数: " << count << std::endl; // 输出: 3
 
    // 使用 std::copy_if 提取满足条件的元素
    std::vector<std::string> matched;
    std::copy_if(words.begin(), words.end(),
                 std::back_inserter(matched),  // 动态插入到 matched 尾部
                 filter);                       // 传入同一个过滤器对象
 
    for (const auto& w : matched) {
        std::cout << w << " ";  // 输出: C++ Programming cpp Computer
    }
    std::cout << std::endl;
 
    return 0;
}

#include <iostream>
#include <numeric>    // std::accumulate
#include <vector>
 
// 一元函数对象：将值翻倍
struct DoubleValue {
    int operator()(int x) const {
        return x * 2;   // 接收 1 个参数，返回其两倍
    }
};
 
// 二元函数对象：加权累加
struct WeightedSum {
    double weight;   // 权重因子
 
    WeightedSum(double w) : weight(w) {}  // 构造时配置权重
 
    // 接收 2 个参数：当前累加值 和 当前元素值
    double operator()(double accumulated, int current) const {
        return accumulated + current * weight;  // 加权累加
    }
};
 
int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
 
    // 使用二元函数对象进行加权累加
    // accumulate(first, last, init, binary_op)
    double result = std::accumulate(
        data.begin(), data.end(),  // 输入范围
        0.0,                       // 初始累加值
        WeightedSum(1.5)           // 权重 1.5 的加权求和器
    );
    // 计算过程: 0 + 1*1.5 + 2*1.5 + 3*1.5 + 4*1.5 + 5*1.5 = 22.5
    std::cout << "加权累加结果: " << result << std::endl;  // 输出: 22.5
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>  // std::bind, std::placeholders
 
int main() {
    std::vector<int> nums = {12, 5, 8, 23, 3, 17, 9};
 
    // === 现代方式：std::bind (C++11) ===
    // std::bind 将 std::greater<int>() 的第二个参数绑定为 10
    // _1 是占位符，代表调用时传入的第一个参数
    auto greater_than_10 = std::bind(
        std::greater<int>(),          // 原始二元函数对象
        std::placeholders::_1,        // 第一个参数由调用时提供
        10                            // 第二个参数固定为 10
    );
 
    // 统计大于 10 的元素个数
    int count = std::count_if(nums.begin(), nums.end(), greater_than_10);
    std::cout << "大于10的元素个数: " << count << std::endl;  // 输出: 3
 
    // === 对比：用 Lambda 更简洁 (C++11) ===
    int count2 = std::count_if(nums.begin(), nums.end(),
                               [](int x) { return x > 10; });  // Lambda 一行搞定
    std::cout << "Lambda 方式: " << count2 << std::endl;        // 同样输出: 3
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
 
struct Counter {
    int count = 0;
    void operator()(int x) {
        if (x % 2 == 0) ++count;
    }
};
 
int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6};
    Counter c;
    std::for_each(v.begin(), v.end(), c);
    std::cout << c.count << std::endl;
    return 0;
}

// ====== 最简 Lambda：无参数、无捕获 ======
auto greet = []() {                    // [] 空捕获列表；() 空参数列表
    std::cout << "Hello Lambda!\n";    // 函数体
};                                     // Lambda 赋值给变量 greet
greet();                               // 像普通函数一样调用
 
// ====== 省略空括号（无参时允许） ======
auto greet2 = [] {                     // 无参数时 () 可以省略
    std::cout << "Hello again!\n";
};
 
// ====== 带参数的 Lambda ======
auto add = [](int a, int b) {         // 接收两个 int 参数
    return a + b;                      // 编译器自动推断返回类型为 int
};
int sum = add(3, 5);                   // sum == 8
 
// ====== 显式指定返回类型 ======
auto divide = [](double a, double b) -> double {  // 尾置返回类型
    if (b == 0.0) return 0.0;                      // 分支一：返回 double
    return a / b;                                   // 分支二：返回 double
};

#include <iostream>
 
int main() {
    int x = 10;                        // 外部变量 x
    int y = 20;                        // 外部变量 y
 
    // ===== 1. 按值捕获单个变量 =====
    auto byVal = [x]() {              // 捕获 x 的副本（此刻 x==10）
        std::cout << x << "\n";        // 输出 10（是副本，不随原变量变化）
        // x = 99;                     // ❌ 编译错误！按值捕获默认为 const
    };
 
    x = 999;                           // 修改外部 x
    byVal();                           // 仍然输出 10 — 副本不受影响
 
    // ===== 2. 按引用捕获单个变量 =====
    auto byRef = [&y]() {             // 捕获 y 的引用
        y += 5;                        // 直接修改外部的 y
        std::cout << y << "\n";        // 输出 25
    };
    byRef();                           // y 现在变成了 25
    std::cout << y << "\n";            // 验证：输出 25，外部 y 确实被修改
 
    // ===== 3. 全部按值捕获 =====
    auto allVal = [=]() {             // 捕获所有用到的外部变量的副本
        std::cout << x << " " << y;   // 可以访问 x 和 y 的副本
    };
 
    // ===== 4. 全部按引用捕获 =====
    auto allRef = [&]() {             // 捕获所有用到的外部变量的引用
        x += 1;                        // 修改外部 x
        y += 1;                        // 修改外部 y
    };
 
    // ===== 5. 混合捕获 =====
    auto mixed = [=, &y]() {          // 默认按值，但 y 按引用
        std::cout << x << "\n";        // x 是副本，只读
        y = 100;                       // y 是引用，可修改
    };
 
    return 0;
}

// 你写的 Lambda：
int a = 42;
auto lam = [a](int x) { return a + x; };
 
// 编译器实际生成的等价代码（伪代码）：
// class __lambda_unique_name {
// private:
//     int a;                           // 按值捕获 → 成员变量副本
// public:
//     __lambda_unique_name(int a) : a(a) {}   // 构造时复制
//     int operator()(int x) const {           // const! 所以不能改 a
//         return a + x;
//     }
// };
// auto lam = __lambda_unique_name(a);         // 用当前 a 值构造

#include <iostream>
 
int main() {
    int count = 0;                     // 外部计数器
 
    // ===== 不加 mutable：编译失败 =====
    // auto bad = [count]() {
    //     count++;                     // ❌ 错误：不能修改 const 副本
    // };
 
    // ===== 加上 mutable：可以修改副本 =====
    auto counter = [count]() mutable { // mutable 移除了 operator() 的 const
        count++;                       // ✅ 修改的是 Lambda 内部的副本
        std::cout << "内部 count = " << count << "\n";
    };
 
    counter();                         // 输出：内部 count = 1
    counter();                         // 输出：内部 count = 2（副本在调用间保持状态！）
    counter();                         // 输出：内部 count = 3
 
    std::cout << "外部 count = " << count << "\n";  // 输出：外部 count = 0（原变量不变）
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>                   // sort, find_if, for_each, count_if, transform
#include <numeric>                     // accumulate
 
int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9, 3, 7, 4, 6};
 
    // ===== 1. sort：自定义排序规则 =====
    std::sort(nums.begin(), nums.end(),
        [](int a, int b) {            // 比较谓词
            return a > b;              // 降序排列
        }
    );
    // nums: {9, 8, 7, 6, 5, 4, 3, 2, 1}
 
    // ===== 2. find_if：查找第一个满足条件的元素 =====
    auto it = std::find_if(nums.begin(), nums.end(),
        [](int n) {                    // 一元谓词
            return n < 5;              // 找第一个小于 5 的元素
        }
    );
    if (it != nums.end()) {
        std::cout << "第一个 < 5 的元素: " << *it << "\n";  // 输出 4
    }
 
    // ===== 3. for_each：对每个元素执行操作 =====
    std::for_each(nums.begin(), nums.end(),
        [](int n) {                    // 对每个元素调用此 Lambda
            std::cout << n << " ";     // 输出每个元素
        }
    );
    std::cout << "\n";
 
    // ===== 4. count_if：统计满足条件的元素个数 =====
    int evenCount = std::count_if(nums.begin(), nums.end(),
        [](int n) {                    // 一元谓词
            return n % 2 == 0;         // 判断是否为偶数
        }
    );
    std::cout << "偶数个数: " << evenCount << "\n";  // 输出 4
 
    // ===== 5. transform：对每个元素进行变换 =====
    std::vector<int> doubled(nums.size());     // 存放变换结果的容器
    std::transform(nums.begin(), nums.end(),
        doubled.begin(),                        // 输出迭代器
        [](int n) {                             // 变换函数
            return n * 2;                       // 每个元素乘以 2
        }
    );
 
    // ===== 6. accumulate + Lambda：自定义累积逻辑 =====
    int product = std::accumulate(nums.begin(), nums.end(),
        1,                                      // 初始值为 1（乘法单位元）
        [](int acc, int n) {                    // 二元操作
            return acc * n;                     // 累积乘积
        }
    );
    std::cout << "所有元素之积: " << product << "\n";
 
    return 0;
}

// ========== 传统方式：定义仿函数类 ==========
struct DescendingCompare {                // 需要单独定义一个类
    bool operator()(int a, int b) const { // 重载 operator()
        return a > b;
    }
};
std::sort(nums.begin(), nums.end(), DescendingCompare());  // 传入实例
 
// ========== Lambda 方式：就地完成 ==========
std::sort(nums.begin(), nums.end(), [](int a, int b) { return a > b; });
// 一行搞定，意图清晰，无需跳转到别处查看定义

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    std::vector<int> scores = {88, 72, 95, 60, 45, 83, 77, 91};
    int threshold = 80;                // 外部阈值，可以动态变化
 
    // ===== 捕获外部变量，实现参数化过滤 =====
    auto highScores = std::count_if(scores.begin(), scores.end(),
        [threshold](int score) {       // 按值捕获 threshold
            return score >= threshold; // 使用外部阈值进行比较
        }
    );
    std::cout << ">=80 的成绩数: " << highScores << "\n";  // 输出 4
 
    // ===== 按引用捕获，在遍历中累积信息 =====
    int sum = 0;                       // 外部累加器
    int count = 0;                     // 外部计数器
    std::for_each(scores.begin(), scores.end(),
        [&sum, &count](int score) {    // 按引用捕获 sum 和 count
            sum += score;              // 累加分数
            count++;                   // 累加计数
        }
    );
    double avg = static_cast<double>(sum) / count;
    std::cout << "平均分: " << avg << "\n";
 
    // ===== 捕获 + 状态：为每个元素生成序号 =====
    int index = 0;                     // 外部序号
    std::for_each(scores.begin(), scores.end(),
        [&index](int score) {          // 按引用捕获 index
            std::cout << "#" << ++index << ": " << score << "\n";
        }
    );
 
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
 
int main() {
    // ===== 泛型 Lambda：参数类型由编译器推断 =====
    auto print = [](const auto& value) {   // auto 参数 → 泛型
        std::cout << value << " ";         // 适用于任何支持 << 的类型
    };
 
    print(42);                             // int → 输出 42
    print(3.14);                           // double → 输出 3.14
    print(std::string("hello"));           // string → 输出 hello
    std::cout << "\n";
 
    // ===== 泛型比较器 =====
    auto greater = [](const auto& a, const auto& b) {
        return a > b;                      // 适用于任何支持 > 的类型
    };
 
    std::vector<int> vi = {3, 1, 4, 1, 5};
    std::sort(vi.begin(), vi.end(), greater);      // 对 int 降序
 
    std::vector<std::string> vs = {"banana", "apple", "cherry"};
    std::sort(vs.begin(), vs.end(), greater);      // 对 string 降序（字典序）
 
    // ===== 编译器为每种参数类型组合生成不同的 operator() =====
    // greater(int, int)    → 生成 operator()(const int&, const int&)
    // greater(string, string) → 生成 operator()(const string&, const string&)
 
    return 0;
}

// auto greater = [](const auto& a, const auto& b) { return a > b; };
// 等价于：
// struct __lambda {
//     template<typename T1, typename T2>
//     bool operator()(const T1& a, const T2& b) const {
//         return a > b;
//     }
// };

#include <iostream>
#include <functional>                  // std::function
#include <vector>
#include <map>
 
int main() {
    // ===== auto：最高效，零开销 =====
    auto lam1 = [](int x) { return x * 2; };  // 编译器知道确切类型
 
    // ===== std::function：类型擦除容器 =====
    std::function<int(int)> func1 = [](int x) { return x * 2; };  // 包装 Lambda
    std::function<int(int)> func2 = [](int x) { return x + 10; }; // 另一个 Lambda
 
    // ===== 用 std::function 实现回调注册 =====
    std::vector<std::function<int(int)>> callbacks;   // 存储多个回调
    callbacks.push_back([](int x) { return x * 2; }); // 加倍
    callbacks.push_back([](int x) { return x + 1; }); // 加一
    callbacks.push_back([](int x) { return x * x; }); // 平方
 
    int val = 5;
    for (auto& cb : callbacks) {                       // 遍历所有回调
        std::cout << cb(val) << " ";                   // 输出 10 6 25
    }
    std::cout << "\n";
 
    // ===== 用 map 实现命令分发器 =====
    std::map<std::string, std::function<double(double, double)>> ops;
    ops["add"] = [](double a, double b) { return a + b; };  // 加法
    ops["sub"] = [](double a, double b) { return a - b; };  // 减法
    ops["mul"] = [](double a, double b) { return a * b; };  // 乘法
    ops["div"] = [](double a, double b) {                    // 除法
        return b != 0 ? a / b : 0.0;
    };
 
    std::cout << ops["mul"](3.0, 4.0) << "\n";   // 输出 12
 
    return 0;
}

#include <functional>
 
std::function<int()> createLambda() {
    int local = 42;                    // 局部变量，函数结束即销毁
    return [&local]() {                // ⚠️ 按引用捕获局部变量
        return local;                  // 💀 函数返回后 local 已被销毁！
    };                                 // 返回的 Lambda 持有悬空引用
}
 
// 正确做法：按值捕获
std::function<int()> createLambdaSafe() {
    int local = 42;                    // 局部变量
    return [local]() {                 // ✅ 按值捕获，副本随 Lambda 存活
        return local;                  // 安全访问副本
    };
}

#include <vector>
#include <functional>
#include <iostream>
 
int main() {
    std::vector<std::function<void()>> funcs;
 
    for (int i = 0; i < 5; i++) {
        // ❌ 错误：所有 Lambda 都引用同一个 i
        // funcs.push_back([&i]() { std::cout << i << " "; });
        // 循环结束后 i == 5，所有 Lambda 输出 5 5 5 5 5（甚至 UB）
 
        // ✅ 正确：按值捕获，每个 Lambda 持有 i 的当时副本
        funcs.push_back([i]() {        // 按值捕获当前循环的 i
            std::cout << i << " ";     // 输出 0 1 2 3 4
        });
    }
 
    for (auto& f : funcs) f();         // 输出: 0 1 2 3 4
    std::cout << "\n";
 
    return 0;
}

#include <iostream>
#include <vector>
 
int main() {
    const int mode = 2;                // 假设由配置决定
 
    // ===== 用 IIFE 初始化 const 变量 =====
    const auto config = [&]() {        // Lambda 立即执行
        if (mode == 1) return std::string("Debug");     // 分支初始化
        if (mode == 2) return std::string("Release");
        return std::string("Unknown");
    }();                               // 注意末尾的 ()，立即调用！
 
    // config 是 const std::string，值为 "Release"
    std::cout << config << "\n";
 
    // ===== 复杂容器的 const 初始化 =====
    const auto table = []() {          // 无捕获，纯计算
        std::vector<int> t;            // 临时构建
        for (int i = 0; i < 10; i++) {
            t.push_back(i * i);        // 平方表
        }
        return t;                      // 返回构建好的容器
    }();                               // 立即调用
 
    // table 是 const vector<int>，不可再修改
    for (int v : table) {
        std::cout << v << " ";         // 0 1 4 9 16 25 36 49 64 81
    }
 
    return 0;
}

#include <memory>
#include <iostream>
 
int main() {
    auto ptr = std::make_unique<int>(42);  // unique_ptr 不可复制
 
    // ===== C++14 初始化捕获：移动语义 =====
    auto lam = [p = std::move(ptr)]() {    // 将 ptr 移动进 Lambda
        std::cout << *p << "\n";           // 在 Lambda 内使用
    };
    // 此时 ptr 已为空（ownership 已转移给 Lambda）
 
    lam();                                 // 输出 42
 
    return 0;
}