是小鬏鬏啊1. 迭代器模式：C++中的遍历艺术
在C++开发中，我们经常需要处理各种数据集合的遍历操作。想象你正在开发一个游戏引擎，需要遍历场景中的所有实体；或是编写一个财务分析工具，要处理股票交易记录的列表。这些场景都面临一个共同问题：如何在不暴露底层数据结构细节的情况下，提供统一的元素访问方式？这就是迭代器模式要解决的核心问题。
迭代器模式（Iterator Pattern）属于行为型设计模式，它提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。这个定义听起来可能有些抽象，让我们用一个现实生活中的例子来理解：就像你用遥控器切换电视频道时，并不需要知道电视台的信号是如何传输的，也不关心电视机内部如何处理这些信号，你只需要按"下一频道"按钮就能遍历所有可用频道。
在C++标准库中，迭代器无处不在。从std::vector到std::map，几乎所有容器都提供了迭代器接口。但标准库的实现只是冰山一角，真正理解迭代器模式的设计思想和实现方式，能让你在需要自定义数据结构时游刃有余。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 迭代器模式的核心组件与实现
2.1 基本结构解析
迭代器模式通常包含以下几个关键角色：
-
迭代器接口（Iterator）：定义访问和遍历元素的接口，通常包括
next(),currentItem(),isDone()等方法。 -
具体迭代器（ConcreteIterator）：实现迭代器接口，负责管理当前遍历的位置。
-
聚合接口（Aggregate）：定义创建相应迭代器对象的接口。
-
具体聚合（ConcreteAggregate）：实现创建相应迭代器的接口，返回一个合适的具体迭代器实例。
让我们用C++代码来展示一个最基本的迭代器模式实现：
cpp复制// 迭代器接口
template<typename T>
class Iterator {
public:
virtual ~Iterator() = default;
virtual T next() = 0;
virtual bool hasNext() const = 0;
};
// 聚合接口
template<typename T>
class Aggregate {
public:
virtual ~Aggregate() = default;
virtual std::unique_ptr<Iterator<T>> createIterator() = 0;
};
// 具体聚合 - 整数集合
class IntCollection : public Aggregate<int> {
std::vector<int> m_data;
public:
void add(int value) { m_data.push_back(value); }
std::unique_ptr<Iterator<int>> createIterator() override;
// 其他集合相关方法...
};
// 具体迭代器
class IntIterator : public Iterator<int> {
const IntCollection& m_collection;
size_t m_index = 0;
public:
explicit IntIterator(const IntCollection& collection)
: m_collection(collection) {}
int next() override {
return m_collection.m_data[m_index++];
}
bool hasNext() const override {
return m_index < m_collection.m_data.size();
}
};
// 实现createIterator
std::unique_ptr<Iterator<int>> IntCollection::createIterator() {
return std::make_unique<IntIterator>(*this);
}
这个实现展示了迭代器模式的基本骨架。在实际应用中，你可能会遇到更复杂的情况，比如支持双向遍历、线程安全迭代器等。
2.2 C++标准库中的迭代器分类
C++标准库定义了多种迭代器类别，每种都有不同的能力和保证：
- 输入迭代器（Input Iterator）：只能单向读取，且只能读取一次（如
istream_iterator） - 输出迭代器（Output Iterator）：只能单向写入（如
ostream_iterator） - 前向迭代器（Forward Iterator）：可以多次读写，单向移动（如
forward_list的迭代器） - 双向迭代器（Bidirectional Iterator）：可以双向移动（如
list的迭代器） - 随机访问迭代器（Random Access Iterator）：支持任意位置的快速访问（如
vector的迭代器）
理解这些分类对于正确使用标准算法非常重要。例如，std::sort需要随机访问迭代器，所以不能用于std::list（它提供的是双向迭代器）。
3. 迭代器模式的高级应用与技巧
3.1 实现STL兼容迭代器
要使自定义迭代器能与STL算法一起工作，需要满足一些额外要求。下面是一个STL兼容迭代器的示例：
cpp复制class MyContainer {
std::vector<int> data;
public:
// 自定义迭代器类
class Iterator {
using iterator_category = std::random_access_iterator_tag;
using value_type = int;
using difference_type = std::ptrdiff_t;
using pointer = int*;
using reference = int&;
pointer ptr;
public:
explicit Iterator(pointer p) : ptr(p) {}
// 必需的操作符重载
reference operator*() const { return *ptr; }
pointer operator->() { return ptr; }
Iterator& operator++() { ++ptr; return *this; }
Iterator operator++(int) { Iterator tmp = *this; ++ptr; return tmp; }
// 随机访问迭代器额外需要的操作
Iterator& operator--() { --ptr; return *this; }
Iterator operator--(int) { Iterator tmp = *this; --ptr; return tmp; }
Iterator& operator+=(difference_type n) { ptr += n; return *this; }
Iterator operator+(difference_type n) const { return Iterator(ptr + n); }
friend difference_type operator-(const Iterator& a, const Iterator& b) { return a.ptr - b.ptr; }
reference operator[](difference_type n) const { return ptr[n]; }
// 比较操作
bool operator==(const Iterator& other) const { return ptr == other.ptr; }
bool operator!=(const Iterator& other) const { return ptr != other.ptr; }
bool operator<(const Iterator& other) const { return ptr < other.ptr; }
};
Iterator begin() { return Iterator(data.data()); }
Iterator end() { return Iterator(data.data() + data.size()); }
// 容器方法...
};
这种实现允许你的自定义容器与所有STL算法无缝协作，如：
cpp复制MyContainer c;
// 填充数据...
std::sort(c.begin(), c.end());
int sum = std::accumulate(c.begin(), c.end(), 0);
3.2 惰性求值与生成器迭代器
迭代器模式不仅限于遍历现有集合，还可以用于实现生成器模式。下面是一个斐波那契数列生成器的例子：
cpp复制class FibonacciIterator {
int a = 0;
int b = 1;
public:
FibonacciIterator() = default;
int operator*() const { return b; }
FibonacciIterator& operator++() {
int next = a + b;
a = b;
b = next;
return *this;
}
FibonacciIterator operator++(int) {
FibonacciIterator tmp = *this;
++(*this);
return tmp;
}
bool operator!=(const FibonacciIterator&) const {
return true; // 无限序列
}
};
class FibonacciSequence {
public:
FibonacciIterator begin() const { return FibonacciIterator(); }
FibonacciIterator end() const { return FibonacciIterator(); }
};
// 使用示例
FibonacciSequence seq;
int count = 0;
for (int num : seq) {
std::cout << num << " ";
if (++count > 10) break;
}
// 输出: 1 1 2 3 5 8 13 21 34 55 89
这种技术在现代C++中非常有用，特别是在处理大型或无限序列时，可以节省内存并提高性能。
4. 迭代器模式的实际应用案例
4.1 树形结构的迭代器实现
处理树形结构时，迭代器模式能提供各种遍历方式（前序、中序、后序、层序）。下面是一个二叉树的中序遍历迭代器实现：
cpp复制template<typename T>
class BinaryTree {
struct Node {
T value;
std::unique_ptr<Node> left;
std::unique_ptr<Node> right;
};
std::unique_ptr<Node> root;
public:
class InOrderIterator {
std::stack<Node*> stack;
void pushLeft(Node* node) {
while (node) {
stack.push(node);
node = node->left.get();
}
}
public:
InOrderIterator(Node* root) {
pushLeft(root);
}
T& operator*() {
return stack.top()->value;
}
InOrderIterator& operator++() {
Node* top = stack.top();
stack.pop();
pushLeft(top->right.get());
return *this;
}
bool operator!=(const InOrderIterator& other) const {
return !stack.empty();
}
};
InOrderIterator begin() {
return InOrderIterator(root.get());
}
InOrderIterator end() {
return InOrderIterator(nullptr);
}
// 树的构建方法...
};
这个实现使用了栈来维护迭代状态，确保中序遍历的正确性。使用时可以像这样：
cpp复制BinaryTree<int> tree;
// 构建树...
for (int value : tree) {
std::cout << value << " ";
}
4.2 组合模式中的迭代器
组合模式经常与迭代器模式结合使用。考虑一个图形编辑器中的场景：
cpp复制class Graphic {
public:
virtual ~Graphic() = default;
virtual void draw() = 0;
virtual void add(std::unique_ptr<Graphic>) {}
virtual void remove(Graphic*) {}
class Iterator {
public:
virtual ~Iterator() = default;
virtual Graphic* next() = 0;
virtual bool isDone() const = 0;
};
virtual std::unique_ptr<Iterator> createIterator() {
return nullptr;
}
};
class Line : public Graphic {
public:
void draw() override { /* 绘制直线 */ }
};
class Rectangle : public Graphic {
public:
void draw() override { /* 绘制矩形 */ }
};
class Picture : public Graphic {
std::vector<std::unique_ptr<Graphic>> children;
public:
void draw() override {
for (auto& child : children) {
child->draw();
}
}
void add(std::unique_ptr<Graphic> graphic) override {
children.push_back(std::move(graphic));
}
class PictureIterator : public Iterator {
Picture& picture;
size_t index = 0;
public:
explicit PictureIterator(Picture& pic) : picture(pic) {}
Graphic* next() override {
return picture.children[index++].get();
}
bool isDone() const override {
return index >= picture.children.size();
}
};
std::unique_ptr<Iterator> createIterator() override {
return std::make_unique<PictureIterator>(*this);
}
};
这种设计允许客户端代码以统一的方式处理单个图形和图形组合，无需关心具体类型：
cpp复制void drawAll(Graphic& graphic) {
if (auto iter = graphic.createIterator()) {
while (!iter->isDone()) {
drawAll(*iter->next());
}
} else {
graphic.draw();
}
}
5. 迭代器模式的性能考量与最佳实践
5.1 迭代器失效问题
在使用迭代器时，最常遇到的问题就是迭代器失效。当底层容器被修改时，指向容器元素的迭代器可能会变得无效。例如：
cpp复制std::vector<int> vec = {1, 2, 3};
auto it = vec.begin();
vec.push_back(4); // 可能导致迭代器失效
*it = 5; // 未定义行为！
不同容器的迭代器失效规则不同：
- vector/string：插入/删除可能使所有迭代器失效
- deque：中间插入/删除使所有迭代器失效，首尾插入只使部分迭代器失效
- list/set/map：只有指向被删除元素的迭代器会失效
提示：在循环中修改容器时，要特别注意迭代器失效问题。使用erase()方法时，它通常会返回下一个有效迭代器。
5.2 自定义迭代器的性能优化
实现高性能自定义迭代器时，可以考虑以下技巧：
-
内联关键操作：确保
operator++和operator*等高频调用操作被内联。 -
减少间接访问：尽量避免在迭代器内部使用指针的指针等多层间接访问。
-
利用现代CPU缓存：设计数据布局时考虑缓存友好性，如使用连续内存。
-
选择性实现迭代器类别：只实现必要的操作，避免不必要的虚函数调用。
例如，一个针对大型数据集优化的分块迭代器可能如下实现：
cpp复制template<typename T>
class ChunkedIterator {
T* current;
T* end;
size_t chunkSize;
public:
using iterator_category = std::random_access_iterator_tag;
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T*;
using reference = T&;
ChunkedIterator(T* ptr, size_t size)
: current(ptr), end(ptr + size), chunkSize(std::min(size, 1024UL)) {}
reference operator*() const { return *current; }
pointer operator->() { return current; }
ChunkedIterator& operator++() {
current += chunkSize;
if (current >= end) current = end;
return *this;
}
// 其他必要操作...
};
这种迭代器可以在处理大型数据集时减少边界检查次数，提高性能。
5.3 现代C++中的迭代器改进
C++17和C++20引入了一些改进迭代器使用体验的特性：
- 结构化绑定+迭代器：
cpp复制std::map<int, std::string> myMap;
for (const auto& [key, value] : myMap) {
// 直接使用key和value
}
- 范围for循环的初始化语句（C++20）：
cpp复制for (auto it = vec.begin(); auto& elem : vec) {
// 可以同时使用it和elem
}
- 范围适配器（C++20 Ranges）：
cpp复制#include <ranges>
auto even = vec | std::views::filter([](int x) { return x % 2 == 0; });
for (int x : even) { /* 只处理偶数 */ }
这些新特性让迭代器的使用更加简洁和安全，减少了出错的可能性。
6. 迭代器模式的替代方案与比较
虽然迭代器模式非常强大，但在某些情况下可能有更好的替代方案：
6.1 基于范围的for循环
C++11引入的基于范围的for循环简化了大多数遍历场景：
cpp复制std::vector<int> vec = {1, 2, 3};
for (int x : vec) {
std::cout << x << " ";
}
这比显式使用迭代器更简洁，但本质上仍然是使用迭代器实现的。
6.2 C++20 Ranges库
C++20的Ranges库提供了更强大的组合和惰性求值能力：
cpp复制#include <ranges>
#include <algorithm>
auto results = vec
| std::views::filter([](int x) { return x % 2 == 0; })
| std::views::transform([](int x) { return x * 2; });
std::ranges::for_each(results, [](int x) { std::cout << x << " "; });
这种方法比传统迭代器更声明式，更易于组合和重用。
6.3 回调/访问者模式
对于某些特殊遍历需求，回调或访问者模式可能更合适：
cpp复制class Tree {
public:
template<typename Visitor>
void traverse(Visitor&& visitor) {
// 实现遍历逻辑，对每个节点调用visitor(node)
}
};
Tree tree;
tree.traverse([](const Node& node) {
std::cout << node.value << " ";
});
这种方法将控制流完全交给调用者，在某些场景下更灵活。
在实际项目中，选择哪种方式取决于具体需求。迭代器模式仍然是C++中最通用和标准化的遍历方式，特别是在需要与现有STL算法交互时。