银星皓月1. 迭代器模式：C++中的遍历艺术
在C++的世界里，我们常常需要处理各种数据集合——从简单的数组到复杂的树形结构。想象你正在开发一个游戏引擎的场景管理系统，需要遍历所有实体进行渲染；或者编写一个金融分析工具，要处理不同数据源的报价信息。这些场景都有一个共同需求：如何在不暴露底层数据结构细节的情况下，统一地访问集合中的元素？这就是迭代器模式要解决的核心问题。
迭代器模式（Iterator Pattern）是GoF 23种设计模式中最常用的行为型模式之一。它提供了一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。在C++标准库中，迭代器早已成为STL（Standard Template Library）的核心概念，从vector到map，几乎所有容器都提供了自己的迭代器实现。
提示：迭代器模式的关键价值在于它将遍历算法与数据结构解耦，使得你可以用相同的方式处理数组、链表、树等各种数据结构。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 迭代器模式的实现原理
2.1 基本结构
一个典型的迭代器模式包含以下几个关键组件：
- Iterator（抽象迭代器）：定义访问和遍历元素的接口，通常包含first()、next()、isDone()和currentItem()等方法。
- ConcreteIterator（具体迭代器）：实现迭代器接口，负责跟踪当前遍历位置。
- Aggregate（抽象聚合类）：定义创建相应迭代器对象的接口。
- ConcreteAggregate（具体聚合类）：实现创建相应迭代器的接口，返回一个合适的具体迭代器实例。
在C++中，我们通常使用抽象基类或模板来实现这些接口。下面是一个简单的迭代器模式实现框架：
cpp复制template <typename T>
class Iterator {
public:
virtual ~Iterator() = default;
virtual void first() = 0;
virtual void next() = 0;
virtual bool isDone() const = 0;
virtual T& currentItem() = 0;
};
template <typename T>
class Aggregate {
public:
virtual ~Aggregate() = default;
virtual std::unique_ptr<Iterator<T>> createIterator() = 0;
};
2.2 STL中的迭代器实现
C++标准库对迭代器模式做了更精细的分类，根据功能将迭代器分为五种类型：
- 输入迭代器（Input Iterator）：只读，只能单向移动（如istream_iterator）
- 输出迭代器（Output Iterator）：只写，只能单向移动（如ostream_iterator）
- 前向迭代器（Forward Iterator）：可读写，只能单向移动（如forward_list的迭代器）
- 双向迭代器（Bidirectional Iterator）：可读写，能双向移动（如list的迭代器）
- 随机访问迭代器（Random Access Iterator）：可读写，支持随机访问（如vector的迭代器）
这种分类使得算法可以根据迭代器的能力选择最优的实现方式。例如，std::sort需要随机访问迭代器，而std::find只需要输入迭代器。
3. 实战：自定义集合的迭代器实现
3.1 二叉树迭代器示例
让我们通过一个具体的例子来理解如何实现自定义迭代器。假设我们有一个简单的二叉树结构：
cpp复制template <typename T>
class TreeNode {
public:
T data;
TreeNode* left;
TreeNode* right;
TreeNode(const T& val) : data(val), left(nullptr), right(nullptr) {}
};
template <typename T>
class BinaryTree {
TreeNode<T>* root;
// ... 其他成员函数
public:
class InOrderIterator : public Iterator<T> {
std::stack<TreeNode<T>*> stack;
void pushLeft(TreeNode<T>* node) {
while (node) {
stack.push(node);
node = node->left;
}
}
public:
InOrderIterator(TreeNode<T>* root) {
pushLeft(root);
}
void first() override {
// 中序遍历的first就是最左节点
// 已经在构造函数中处理
}
void next() override {
TreeNode<T>* current = stack.top();
stack.pop();
pushLeft(current->right);
}
bool isDone() const override {
return stack.empty();
}
T& currentItem() override {
return stack.top()->data;
}
};
std::unique_ptr<Iterator<T>> createIterator() {
return std::make_unique<InOrderIterator>(root);
}
};
这个实现展示了中序遍历二叉树的迭代器，使用了栈来维护遍历状态。在实际使用中，我们可以这样遍历二叉树：
cpp复制BinaryTree<int> tree;
// ... 填充树数据
auto iter = tree.createIterator();
for (iter->first(); !iter->isDone(); iter->next()) {
std::cout << iter->currentItem() << " ";
}
3.2 迭代器的性能考量
实现迭代器时需要考虑几个性能关键点：
- 内存占用：迭代器应该尽可能轻量。上面的二叉树迭代器使用了栈，这在最坏情况下（退化为链表）会有O(n)的空间复杂度。
- 遍历效率：不同的遍历方式有不同的时间复杂度。例如，前序遍历通常比中序遍历更容易实现且效率更高。
- 拷贝代价：迭代器应该是可拷贝的，但拷贝操作应该尽可能高效。对于复杂的状态（如上面的栈），需要考虑深拷贝还是浅拷贝。
注意：在C++17中引入的std::optional可以用来优化某些迭代器实现，避免在isDone()和currentItem()之间可能出现的竞态条件。
4. 迭代器模式的高级应用
4.1 过滤迭代器
有时候我们需要遍历集合中满足特定条件的元素，这时可以创建过滤迭代器：
cpp复制template <typename T, typename Predicate>
class FilterIterator : public Iterator<T> {
std::unique_ptr<Iterator<T>> inner;
Predicate pred;
void advanceToValid() {
while (!inner->isDone() && !pred(inner->currentItem())) {
inner->next();
}
}
public:
FilterIterator(std::unique_ptr<Iterator<T>> i, Predicate p)
: inner(std::move(i)), pred(p) {
advanceToValid();
}
// 实现其他接口...
};
这种模式在STL中体现为算法如std::copy_if，但在某些情况下，封装为迭代器可以提供更灵活的用法。
4.2 线程安全迭代器
在多线程环境中，迭代器的安全性成为一个重要考虑。我们可以实现一种"快照"迭代器，在创建时复制集合的状态：
cpp复制template <typename T>
class SnapshotIterator : public Iterator<T> {
std::vector<T> snapshot;
size_t current;
public:
template <typename Iter>
SnapshotIterator(Iter begin, Iter end)
: snapshot(begin, end), current(0) {}
// 实现其他接口...
};
这种迭代器虽然消耗更多内存，但保证了遍历过程中的线程安全。
4.3 组合迭代器
对于复杂的数据结构（如图），可能需要同时维护多个遍历状态。组合迭代器可以封装这些复杂性：
cpp复制class GraphIterator : public Iterator<Node> {
std::queue<Node*> bfsQueue;
std::unordered_set<Node*> visited;
public:
GraphIterator(Node* start) {
if (start) {
bfsQueue.push(start);
visited.insert(start);
}
}
// 实现BFS遍历的其他接口...
};
5. 迭代器模式的陷阱与最佳实践
5.1 常见问题与解决方案
-
迭代器失效问题：
- 场景：在遍历过程中修改集合（如删除元素）
- 解决方案：使用版本号检查，或在修改时使所有迭代器失效
-
多趟遍历问题：
- 场景：某些迭代器（如输入流迭代器）只能遍历一次
- 解决方案：明确文档说明，或提供缓存功能
-
性能陷阱：
- 场景：嵌套迭代器导致算法复杂度爆炸
- 解决方案：预先评估复杂度，必要时提供专门的优化迭代器
5.2 C++11/14/17中的现代迭代器技术
-
基于范围的for循环：
cpp复制for (auto& item : collection) { // 使用item }这种语法糖背后依赖于begin()和end()方法，使得自定义集合更容易使用。
-
反向迭代器：
cpp复制for (auto it = vec.rbegin(); it != vec.rend(); ++it) { // 反向遍历 } -
移动迭代器：
cpp复制std::vector<std::string> newStrings( std::make_move_iterator(oldStrings.begin()), std::make_move_iterator(oldStrings.end()) );
5.3 设计建议
-
尽量使迭代器轻量：迭代器应该只是遍历状态的包装，不应该包含业务逻辑。
-
提供const迭代器：对于不需要修改元素的场景，提供const版本的迭代器可以提高代码的安全性和可读性。
-
考虑异常安全：确保迭代器操作（特别是拷贝和移动）不会因为异常而破坏集合状态。
-
文档化迭代器特性：明确说明你的迭代器属于哪种类型（前向、双向等），以及它在并发环境中的行为。
在实际项目中，我发现迭代器模式最强大的地方在于它能够将复杂的数据结构遍历逻辑封装起来，使得算法可以独立于数据结构演化。例如，我们曾经将一个使用原始指针遍历的遗留系统逐步迁移到基于迭代器的现代C++实现，而保持上层业务代码几乎不变。这种解耦带来的灵活性在长期维护中显示出巨大价值。