博主介绍：程序喵大人
- 35 - 资深C/C++/Rust/Android/iOS客户端开发
- 10年大厂工作经验
- 嵌入式/人工智能/自动驾驶/音视频/游戏开发入门级选手
- 《C++20高级编程》《C++23高级编程》等多本书籍著译者
- 更多原创精品文章，首发gzh，见文末
- 👇👇记得订阅专栏，以防走丢👇👇
😉C++基础系列专栏
😃C语言基础系列专栏
🤣C++大佬养成攻略专栏
🤓C++训练营
👉🏻个人网站
好文推荐：
【C++进阶】STL容器与迭代器 - 01 STL 容器先解决元素放在哪里
【C++进阶】STL容器与迭代器 - 02 vector 为什么是一段会长大的连续数组
【C++进阶】STL容器与迭代器 - 03 string、array 和 deque 各自守住什么边界
【C++进阶】STL容器与迭代器 - 04 list 和 forward_list 用节点换稳定位置
【C++进阶】STL容器与迭代器 - 05 map 和 set 为什么按键保持有序
【C++进阶】STL容器与迭代器 - 06 unordered_map 和 unordered_set 用哈希桶换平均效率
前面六章我们逐个拆解了各种容器的内部结构，vector 的连续内存、list 的双向节点、map 的树、unordered_map 的哈希桶。这些结构差异巨大，但标准库算法在面对它们时毫不露怯：std::find 能同时处理 vector<int>、list<string> 和 map<string, int>，std::copy 能把任意容器的元素搬到另一个容器里。算法是怎么做到不关心底层容器类型的？
答案是迭代器。容器通过 begin() 和 end() 暴露一对迭代器，算法接收这对迭代器作为范围参数，通过解引用（*it）读元素、通过递增（++it）移动位置、通过与 end() 比较（it != end）判断是否到达终点。迭代器把"不同的容器"翻译成"统一的范围"，让算法可以只依赖这个翻译后的接口工作，而不用污染到容器的具体实现。
半开区间 [begin, end)
begin() 返回的迭代器指向容器的第一个有效元素，对于非空容器，*begin() 是合法的。end() 返回的迭代器不指向任何有效元素，它指向最后一个有效元素之后的虚拟位置，常被称为"尾后哨兵"（past-the-end sentinel）。这两个迭代器定义的区间 [begin, end) 是一个半开区间：包含 begin，不包含 end。
半开区间的设计不是偶然的精巧，它的稳定性历经了几十年的验证：
空范围自然表达：当 begin() == end() 时，范围为空，不需要额外的 empty_range 标记或特殊的起点值。一个空容器的 begin() 和 end() 返回相同的迭代器，算法判断 it != end 时立即退出，不需要特殊处理。
长度计算直接：对于随机访问迭代器，范围长度就是 end - begin，直接做指针减法。对于其他迭代器，std::distance(begin, end) 处理所有情况，返回元素个数。不会出现"闭区间 begin, end 包含 end，所以长度要加一"这种容易写错的尴尬。
边界拼接无重叠：如果你有一个范围 [a, b) 和紧挨在后面的范围 [b, c)，把两个范围拼在一起就是 [a, c)，边界元素 b 不会被重复包含。这在分治处理中极大简化了区间拼接，你不需要担心"前一半的最后一个元素和后一半的第一个元素是同一个"。
end() 只应该被用作边界标记，不能解引用。写 *v.end() 是不被定义的，end() 不指向任何构造好的元素，取它的内容没有意义。这个规则的唯一作用是让算法正确判断终止条件。
迭代器的基本操作
任何迭代器都至少支持三种操作：解引用获取元素（*it）、移动到下一个位置（++it）、与另一个迭代器比较（it != other 或 it == other）。这三种操作构成迭代器的最小协议，满足了顺序遍历的所有需要：
cpp
template <typename Iterator>
void print_all(Iterator first, Iterator last) {
for (auto it = first; it != last; ++it)
std::cout << *it << ' ';
}这个函数可以作用于任何提供迭代器的容器，vector、list、map、unordered_map，甚至原生数组（通过 std::begin(arr) 和 std::end(arr)）。在每个容器上，++it 做的事情完全不同：在 vector 上它只是指针加一，在 list 上它沿着 node->next 指针跳转，在 map 上它沿着树的中序遍历找到下一个节点。但函数模板 print_all 不关心这些，它只依赖迭代器的抽象行为，每步获取一个元素，直到碰到尾边界。
迭代器的第二个关键行为是：两个指向同一容器内同一位置的迭代器，在它们任何一个对容器做了修改之前，算出的 distance 和比较结果是一致的。这意味着你可以用 it1 == it2 判断它们是否指向同一个元素，也可以保存一个 begin() 的快照来标记某个重要位置，前提是之后没有修改容器。修改容器可能让某些容器的迭代器失效，这个主题我们留到下一章详细展开。
迭代器能力阶梯
不是所有迭代器都只有"往前走、读元素"的简单能力。STL 定义了五种迭代器类别（iterator category），从功能上构成一个递增的能力阶梯。注意这些类别是概念（concept）而非通过继承实现的类层次，一个迭代器满足哪种类别的要求，取决于它支持哪些操作，而不是它继承自哪个基类。
输入迭代器（Input Iterator）：最基础的只读迭代器。支持 *it（读取）、++it（前进）、it != other（比较）。关键的约束是单程：读完一次后不能倒回去再读，它面向流的特性意味着数据源可能是一次性的（如从键盘、网络读取）。std::istream_iterator 是典型的输入迭代器。
输出迭代器（Output Iterator）：只写迭代器。支持 *it = value（写入）、++it（前进）。同样是单程的，写过一次后不能倒回去修改。对同一个位置的写入可能只允许一次。std::ostream_iterator 和 std::back_insert_iterator 是典型实现。
前向迭代器（Forward Iterator）：可读可写，支持多趟遍历，你可以多次从头到尾遍历同一个范围，每次都得到同样的结果。前向迭代器是输入和输出迭代器能力的超集。std::forward_list 的迭代器就是前向迭代器，它只能往前走，不能后退，但保证多趟遍历的稳定性。
双向迭代器（Bidirectional Iterator）：在前向迭代器的能力上增加了 --it（后退）。这意味着可以从任意位置前后移动，也可以从 end() 往回遍历。std::list、std::map、std::set 的迭代器都是双向迭代器。
随机访问迭代器（Random Access Iterator）：在双向迭代器的能力上增加了常数时间的任意位置跳转，it + n、it - n、it[n]、it1 < it2。指针运算的完整语义：两个迭代器可以相减得到距离，可以加上偏移得到新位置。std::vector、std::deque、std::array、std::string 的迭代器都是随机访问迭代器。
连续迭代器（Contiguous Iterator）：C17 引入的概念（C20 正式标准化），它是随机访问迭代器的特化，不仅支持任意跳转，而且保证元素在内存中物理连续排列。std::vector 和 std::array 的迭代器满足这个要求，std::deque 不满足（因为分段存储）。
这些能力等级不是为分类而分类，算法通过它们来决定自己能做什么。std::sort 要求随机访问迭代器，因为排序的核心步骤（分区、交换相隔很远的元素）必须靠随机跳转来实现。std::reverse 要求双向迭代器，因为要反转一个范围，必须能从两端向中间同时推进。std::find 只要求输入迭代器，找元素只需要单程扫描。算法对迭代器能力的最低要求写在标准里，也写在编译器的错误信息里，当你尝试对 list 调用 std::sort 时，编译器会告诉你 std::sort 需要随机访问迭代器，但 list 只提供双向迭代器。
不同容器提供不同能力的迭代器
每个标准容器提供的迭代器能力由它的内部结构决定，这张对照表值得记住：
| 容器 | 迭代器类别 | 支持的操作 |
|---|---|---|
| vector | 随机访问（连续） | ++, --, +n, -n, n, <, > |
| array | 随机访问（连续） | 同上 |
| string | 随机访问（连续） | 同上 |
| deque | 随机访问 | ++, --, +n, -n, n, <, > |
| list | 双向 | ++, -- |
| forward_list | 前向 | ++ |
| map/set | 双向 | ++, -- |
| unordered_map/set | 前向 | ++ |
注意 unordered_map 的迭代器是前向的，不是双向的，你可以在桶内沿着链表往前走，但不能往回退。这个差异来自于哈希桶实现的自然约束：桶内链表是单向的。而 map 的树结构每个节点都存储了父节点指针和左右子节点指针，天然支持双向遍历。
迭代器能力差异的一个常见后果是：你写了一个函数模板，期待对任意容器都能用，但内部使用了一个要求随机访问迭代器的操作（比如 std::sort、operator[] 或 it + n），结果只能在 vector/deque/array 上编译通过，在 list/map 上直接报错。这不是设计瑕疵，迭代器的能力限制恰恰阻止了你在结构不支持的操作上犯错。如果你确实需要对 list 排序，list 有自己的 sort() 成员函数，它的实现针对链表做了适配（归并排序，不需要随机访问，也不需要搬动元素）。
算法如何要求迭代器
标准库算法在声明时就通过迭代器模板参数表达了能力要求，尽管这种表达在传统 C++中只是文档约定而非编译器检查（C++20 的 concepts 改变了这一点）。std::sort 声明为接受 RandomIt 模板参数，std::reverse 接受 BidirIt，std::find 接受 InputIt。当你传递给算法的迭代器不满足其最低要求时，得到的错误信息会非常冗长，因为模板错误会展开整条实例化链。这是传统 STL 的主要痛点，C++20 的 concepts 通过编译期检查大大改善了错误信息质量，但基本的能力匹配逻辑不变。
cpp
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
// 通用打印，只要求输入迭代器
template <typename Iterator>
void print_range(Iterator first, Iterator last) {
for (auto it = first; it != last; ++it)
std::cout << *it << ' ';
std::cout << '\n';
}
int main() {
std::vector<int> v{3, 1, 4, 1, 5, 9};
std::list<int> lst{10, 20, 30};
// 通用打印：vector 和 list 都能用
print_range(v.begin(), v.end()); // 3 1 4 1 5 9
print_range(lst.begin(), lst.end()); // 10 20 30
// std::sort 要求随机访问迭代器
std::sort(v.begin(), v.end()); // OK, vector::iterator 是随机访问
// std::sort(lst.begin(), lst.end()); // 编译错误!
// list 自备 sort
lst.sort(); // OK
// std::advance 按迭代器能力选择最有效的推进方式
auto it = v.begin();
std::advance(it, 3); // 随机访问: O(1) 直接 +3
std::cout << "v[3] = " << *it << '\n';
auto lit = lst.begin();
std::advance(lit, 2); // 双向迭代器: O(n) 逐个 ++
std::cout << "list 第3个: " << *lit << '\n';
// std::distance 计算距离
std::cout << "v 的元素数: " << std::distance(v.begin(), v.end()) << '\n';
std::cout << "lst 的元素数: " << std::distance(lst.begin(), lst.end()) << '\n';
}注意 std::advance 在 vector 上一条指针加法指令就完成了（O(1)），在 list 上则老老实实循环递增 2 次（O(n)）。同一个函数调用，不同的代价，std::advance 内部通过 iterator_traits 和标签派发（tag dispatch）在编译期选择了最合适的实现路径。这是 STL 泛型编程的核心技巧，但使用者只需要知道一件事：std::advance 的效率等于该迭代器走 n 步的效率，不要在 list 上反复 advance 大距离。
迭代器的限制与边界
迭代器让算法不必关心容器类型，但它不解决两个核心问题：
范围有效性：算法假定传入的迭代器范围是有效的，begin 在 end 之前（或相等表示空范围），且两者来自于同一个容器。将不同容器的迭代器混用在同一个范围中是未定义的。将已经失效的迭代器传给算法也是未定义的。这些错误不会被检查，编译器不会报错，运行时也不一定崩溃，但程序的状态已经被破坏。
迭代器失效：迭代器是对容器内部状态的"快照"。当容器结构发生重大变化时，vector 扩容、unordered_map rehash、任何容器的 erase 删除该迭代器指向的元素，迭代器就不再有效。这是一个独立的大主题，我们下一章完整展开，但这里需要先记住一条规则：保存迭代器后修改容器是需要审查的代码味道。
这两个问题的共同根源是：迭代器把"位置"从"结构"中独立了出来，但位置的有效性始终依赖结构的稳定性。
从传统迭代器到 C++20 Ranges
C++20 引入的 std::ranges 在迭代器的基础上提供了一个更高层次的抽象：把迭代器对和算法调用封装成范围对象和管道操作。你不再需要单独传递 v.begin() 和 v.end()，而是直接传递 v（或 std::ranges::subrange），算法会自动获取范围。但传统的迭代器-范围模型是理解 C++STL 的基础，所有的 ranges 实现都建立在迭代器之上，ranges 并没有替换迭代器，而是给迭代器穿上了一层更方便的外套。先把传统迭代器的半开区间和分类吃透，进到 ranges 世界时你会看到清晰的延续脉络。
迭代器还有一个很重要的设计价值：它让"数据来源"和"处理逻辑"分离。一个算法只要拿到 [first, last)，就不必知道元素来自数组、vector、文件流、生成器还是某个视图。这个分离让 C++ 标准库可以用同一套算法处理大量不同数据结构，也让你自己的代码更容易复用。比如一个统计函数接收迭代器范围，它既能统计 vector<int>，也能统计 array<int, N>，甚至能统计某个过滤视图里的元素。函数不拥有容器，也不关心容器生命周期，只在调用者给出的范围内工作。
但这种自由也带来责任。迭代器范围没有内置所有权，算法不会替你延长容器生命周期。如果你从一个临时容器拿到迭代器，然后临时对象销毁，迭代器立刻失效；如果你把一个局部 vector 的迭代器保存到全局状态里，函数返回后它们也变成悬空位置。现代 C++ 的 ranges 在一定程度上通过 borrowed range、view、owning view 等概念让这些问题更显性，但底层原则没变：迭代器只描述位置，不拥有位置背后的数据。
迭代器类别也会影响模板约束。旧式泛型代码常常在函数体里写 it + n，等到传入 list 迭代器时才爆出一长串编译错误。更好的写法是在接口层表达要求：需要随机访问就用 C++20 concept 约束 std::random_access_iterator，只需要单程扫描就接受 std::input_iterator。把能力要求写在接口上，错误会更早、更清楚，也能避免使用者误以为所有迭代器都像指针一样强大。
调试迭代器问题时，最有效的问题通常不是"这个迭代器类型是什么"，而是"它来自哪个容器、此后容器有没有被修改、它和 end 是否仍属于同一个范围"。许多看似随机的崩溃都来自这三件事之一：不同容器的迭代器被混在一起，容器扩容后继续使用旧迭代器，或者删除元素后循环又递增了失效的迭代器。只要把迭代器看成"依赖容器结构的当前位置票据"，这些问题就会变得容易审查。
迭代器让 STL 的接口非常轻量，但它没有运行时防护网。调试版标准库可能帮你检查一部分越界和失效，发布版通常不会。写 C++ 代码时要把迭代器有效性当成程序员自己的不变量来维护：范围从同一个容器来，生命周期覆盖算法调用，修改容器后重新评估旧位置，算法要求的迭代器能力得到满足。做到这几点，迭代器就是通用游标；做不到，它就会变成最隐蔽的悬空引用。
把迭代器放进函数接口时，要让能力要求尽量窄。一个只打印元素的函数只需要输入迭代器或前向迭代器；一个需要反向走的函数才需要双向迭代器；一个要用 it + n、last - first 的函数才需要随机访问迭代器。能力要求越宽，能接入的容器越少。很多泛型代码本来可以处理 list，却因为随手写了 last - first 而把自己限制在连续或随机访问容器上，这属于接口层面的过度要求。
迭代器还会影响复杂度文档。函数签名看起来一样，传入不同迭代器时成本可能完全不同。std::distance(first, last) 在 vector 上是常数时间，在 list 上是线性时间；std::advance(it, n) 在随机访问迭代器上是一次跳转，在前向迭代器上是 n 次递增。因此，写模板函数时不能只在实现里调用这些工具，还要在注释或约束里说明复杂度依赖迭代器类别。否则调用方会以为一行工具函数永远便宜，结果在链表上把 O(n) 嵌进了循环，变成 O(n²)。
Ranges 没有取消这些成本，只是把接口变得更整洁。std::ranges::sort(v) 比 std::sort(v.begin(), v.end()) 更不容易传错范围，但它仍然要求随机访问范围；views::filter 可以懒惰地产生过滤视图，但视图里的迭代器仍然依赖底层数据的生命周期。语法更现代，不变量没有消失。理解传统迭代器，才能正确使用 ranges，而不是把管道语法当成免维护的魔法。
还有一类迭代器来自流，比如 std::istream_iterator<int>。它们通常只满足输入迭代器要求，只能向前读一次，读过的数据不会自动保存。把这种迭代器传给多遍算法会出问题，因为算法如果想第二次扫描范围，数据流已经前进了。这个例子说明迭代器不一定指向内存中的容器元素，也可能代表一个一次性数据源。迭代器类别表达的正是这种能力差异：能不能多次遍历，能不能后退，能不能随机跳转。
输出迭代器也是同一套模型的一部分。std::back_inserter(v) 看起来像迭代器，解引用赋值时实际调用 v.push_back；std::ostream_iterator 写入时实际向输出流发送数据。算法通过输出迭代器把结果写到目标位置，不需要知道目标是容器、文件还是控制台。理解了输入、输出、前向、双向、随机访问这些类别，STL 算法接口就会从"奇怪的模板参数"变成一套清晰的数据通道。
写自己的工具函数时，尽量让迭代器范围保持成对出现，不要只保存 begin 忘记 end，也不要把来自不同容器的端点拼成一个范围。C++23 之后的 ranges 风格会让这件事更安全，因为范围对象把起点和终点包在一起；但在传统接口里，这个不变量仍然靠程序员维护。凡是函数签名里出现两个迭代器，就应该默认审查它们是否来自同一范围。
迭代器的价值正是在这里：它足够轻，能让算法广泛复用；它也足够薄，不会替你保存所有权和结构版本。轻和薄是一体两面。接受这个设计，才能写出既泛型又清楚边界的 STL 代码。
调试泛型算法时，可以把问题拆成三层：范围是否有效，迭代器能力是否满足算法要求，算法内部是否修改了底层容器。第一层对应生命周期，第二层对应编译期约束，第三层对应失效规则。很多错误看起来像模板报错或随机崩溃，沿着这三层查下去，通常能很快定位到真正的边界破坏。
迭代器不是语法糖，它是 STL 把容器和算法拆开的核心接口。没有迭代器，每个算法都要为每个容器写一份；有了迭代器，算法只需要面对范围和能力。这个设计让 C++ 标准库显得复杂，但也让它足够可组合。
这也是为什么后续学习算法时，第一反应不应该是"这个算法属于哪个容器"，而应该是"这个算法要求什么迭代器能力"。只要能力满足，算法就能接入；能力不满足，容器名字再熟也没用。迭代器把问题从类型名字转成能力约束，这是 STL 泛型设计最重要的转向。
这一转向会贯穿后面的算法学习。看到 sort，问它为什么需要随机访问；看到 find，问它为什么只需要输入范围；看到 copy，问输入和输出两端分别需要什么能力。算法的门槛都写在迭代器能力里，读懂这层门槛，就能读懂 STL 的大部分接口设计。
失效：迭代器能遍历，也能作废
迭代器一个最大的功用是让容器可以像一本书一样被逐页翻阅。但翻书有一个前提，书的页码结构没变。如果在翻阅过程中，有人把书页撕掉、换了页码顺序、或者整本书换了版次，你手里的页码标记就全对不上了。
这个比喻恰好描述了迭代器失效：容器结构发生变化后，之前获取的迭代器可能指向了错误的或已被销毁的位置。这种失效不是迭代器的设计缺陷，它是对容器物理真相的诚实反映。不同容器的内部结构差异有多大，它们的迭代器失效规则差异就有多大。接下来我们逐个拆解。
码字不易，欢迎大家点赞，关注，评论，谢谢！