2、C++基础回顾：模板、迭代器、函数对象、lambda表达式在STL中的核心作用

STL（Standard Template Library）之所以被称为“标准模板库”，其灵魂就在于“模板”二字。但仅有模板还不够——容器与算法之间需要一座桥梁来遍历数据，算法需要可定制的行为策略来适应不同业务，而函数对象与lambda表达式则为这种定制提供了轻量而强大的手段。本章将深入剖析这四大语言特性在STL中各自扮演的角色，以及它们如何协同工作，构成现代C++泛型编程的基石。

2.1 模板：STL的“基因”与编译期多态

核心原理：模板是C++实现泛型编程的核心机制。它允许程序员编写与类型无关的代码，编译器在实例化时根据实际使用的类型生成具体代码。STL中的容器（如 std::vector<T>）、算法（如 std::sort）和迭代器（如 std::vector<T>::iterator）全部是类模板或函数模板。模板的编译期多态特性意味着类型检查发生在编译阶段，而非运行时，这既保证了类型安全，又避免了虚函数带来的运行时开销。

判断方法：识别一个类型是否为模板，可以看其声明中是否包含 template<typename T> 或 template<class T>。在STL中，几乎所有组件都以模板形式存在。例如 std::map<K, V, Compare, Allocator> 有四个模板参数，其中第三个参数 Compare 默认使用 std::less<K>，这就是函数对象作为模板参数的典型应用。

// 模板作为STL组件的基石
template<typename T>
class MyVector {
    T* data;
    size_t size;
public:
    T& operator[](size_t i) { return data[i]; }
    // 迭代器类型定义
    using iterator = T*;
    iterator begin() { return data; }
    iterator end() { return data + size; }
};

// 使用模板实例化
MyVector<double> vec;  // 编译期生成 double 版本代码

2.2 迭代器：连接容器与算法的“智能指针”

核心原理：迭代器是STL设计模式中的核心抽象。它提供了一种统一的方式来遍历不同数据结构（数组、链表、树、哈希表等）中的元素，而无需暴露容器的内部实现。迭代器本质上是对指针的泛化，它重载了 operator*、operator++、operator== 等操作符，使得算法可以以完全相同的方式处理不同容器。

迭代器分类与能力：

操作流程：使用迭代器时，通常遵循“获取迭代器 → 遍历/操作 → 判断终止”的流程。例如 for(auto it = vec.begin(); it != vec.end(); ++it)。C++11 引入了范围 for 循环，其底层仍然依赖迭代器。

// 迭代器统一访问不同容器
std::vector<int> v = {1, 2, 3, 4, 5};
std::list<int> l = {10, 20, 30};

// 同一个算法模板，适用于不同容器
auto print = [](const auto& container) {
    for (auto it = container.begin(); it != container.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << "\n";
};
print(v);  // 输出: 1 2 3 4 5
print(l);  // 输出: 10 20 30

2.3 函数对象：带状态的“可调用类”

核心原理：函数对象（Functor）是重载了 operator() 的类对象。与普通函数相比，函数对象可以拥有成员变量，因此可以保存状态；同时，由于是类类型，可以作为模板参数传递，且可能被编译器内联，性能优于函数指针。STL 算法大量使用函数对象作为“策略参数”，例如 std::sort 的第三个参数、std::accumulate 的第四个参数。

判断方法：判断一个类型是否为函数对象，检查其是否定义了 operator()。STL 提供了大量预定义函数对象，如 std::greater<T>、std::plus<T>、std::logical_and<T> 等，它们定义在 <functional> 头文件中。

// 自定义函数对象：统计大于阈值的元素个数
class GreaterThan {
    int threshold;
public:
    explicit GreaterThan(int t) : threshold(t) {}
    bool operator()(int value) const {
        return value > threshold;
    }
};

std::vector<int> data = {5, 12, 8, 20, 3, 15};
int count = std::count_if(data.begin(), data.end(), GreaterThan(10));
// count = 3 (12, 20, 15)

实战场景：函数对象特别适合需要“记忆”状态的场景。例如，在统计平均值时，可以创建一个函数对象，内部累加总和与计数，然后通过 std::for_each 一次性完成遍历。

2.4 Lambda表达式：现代C++的“匿名函数对象”

核心原理：Lambda表达式是C++11引入的语法糖，它本质上是一个匿名的函数对象。编译器会将 lambda 表达式转换为一个未命名的类类型，并生成 operator()。Lambda 的捕获列表（[]）决定了它能访问哪些外部变量：[=] 按值捕获，[&] 按引用捕获，[this] 捕获当前对象指针。

操作流程：Lambda 的基本语法为 [捕获列表](参数列表) mutable(可选) -> 返回类型(可选) { 函数体 }。在STL算法中，lambda 通常用于替代简单的函数对象，使代码更紧凑、可读性更强。

// Lambda 替代函数对象
std::vector<int> scores = {85, 92, 68, 75, 90};

// 使用 lambda 统计及格人数（>=60）
int pass_count = std::count_if(scores.begin(), scores.end(),
                               [](int s) { return s >= 60; });

// 使用 lambda 按降序排序
std::sort(scores.begin(), scores.end(),
          [](int a, int b) { return a > b; });

// 捕获外部变量
int min_score = 80;
auto above_min = std::find_if(scores.begin(), scores.end(),
                              [min_score](int s) { return s > min_score; });

案例拆解：假设我们需要对一个学生成绩表进行多重排序：先按总分降序，总分相同则按数学成绩降序。使用 lambda 可以优雅地实现复合排序条件。

struct Student {
    std::string name;
    int total;
    int math;
};

std::vector<Student> students = {
    {"Alice", 280, 95}, {"Bob", 275, 98},
    {"Carol", 280, 92}, {"Dave", 270, 88}
};

std::sort(students.begin(), students.end(),
          [](const Student& a, const Student& b) {
              if (a.total != b.total) return a.total > b.total;
              return a.math > b.math;  // 总分相同，按数学降序
          });

// 排序结果: Alice(280,95), Carol(280,92), Bob(275,98), Dave(270,88)

2.5 四大特性的协同工作与综合案例

核心原理：模板提供类型参数化，迭代器提供统一访问接口，函数对象/lambda 提供可定制的操作策略。三者结合，使得STL算法可以“一次编写，到处使用”，且性能接近手写循环。

综合案例：实现一个通用的“分组统计”功能，统计一个字符串数组中各单词的长度分布。

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

int main() {
    std::vector<std::string> words = {"apple", "banana", "cherry", "date", "elderberry"};
    
    // 使用 map 存储长度 -> 单词列表
    std::map<size_t, std::vector<std::string>> groups;
    
    // 模板 + 迭代器 + lambda 协同
    std::for_each(words.begin(), words.end(),
                  [&groups](const std::string& w) {
                      groups[w.size()].push_back(w);
                  });
    
    // 输出结果
    for (const auto& [len, word_list] : groups) {
        std::cout << "长度 " << len << ": ";
        for (const auto& w : word_list) {
            std::cout << w << " ";
        }
        std::cout << "\n";
    }
    return 0;
}
// 输出:
// 长度 4: date
// 长度 5: apple
// 长度 6: banana cherry
// 长度 10: elderberry

常见误区与总结：

• 误区一：认为 lambda 和函数对象完全等价。实际上，lambda 不能递归调用（除非使用 std::function 包装），且无法直接定义成员变量（但可通过捕获实现类似效果）。
• 误区二：忽略迭代器类别。将随机访问迭代器才能使用的算法（如 std::sort）应用于 std::list 的迭代器会导致编译错误。应使用 std::list::sort 成员函数。
• 误区三：模板代码全部放入 .cpp 文件。这会导致链接错误。模板定义必须放在头文件中，或在实例化前可见。
• 误区四：过度使用 lambda 导致代码难以阅读。当 lambda 体超过 5 行时，建议提取为具名函数对象或普通函数。

复盘总结：模板、迭代器、函数对象和 lambda 表达式是理解STL的四个关键钥匙。模板定义了“形状”，迭代器定义了“路径”，函数对象和 lambda 定义了“策略”。掌握这四者的协同关系，就能自如地组合STL组件，写出既高效又优雅的泛型代码。在实际开发中，优先使用 lambda 表达简单逻辑，使用具名函数对象表达复杂或需要复用的逻辑，并始终关注迭代器类别与容器特性的匹配。