注意：复现代码时，确保 VS2022 使用 C++17/20 标准以支持现代特性。
遍历聚合对象的统一方式
1. 模式定义与用途
核心思想
- 迭代器模式：提供一种方法顺序访问聚合对象的元素，而无需暴露其内部表示。
- 关键用途：
1.统一遍历接口：为不同数据结构（如数组、链表、树）提供一致的遍历方式。
2.支持多种遍历策略：前向、反向、条件过滤等。
3.简化聚合类设计：将遍历逻辑从聚合类中分离。
经典场景
- STL容器的迭代器（如std::vector::iterator）。
- 自定义集合类（如链表、图）的遍历。
- 数据库查询结果的逐行遍历。
2. 模式结构解析
UML类图
+---------------------+ +---------------------+
| Aggregate | | Iterator |
+---------------------+ +---------------------+
| + createIterator() |<>------->| + next(): void |
+---------------------+ | + hasNext(): bool | ^ +---------------------+ | ^ | | +-------+-------+ +---------+---------+ | | | |
+---------------------+ +-------------------+ +----------------+
| ConcreteAggregate | | ConcreteIterator | | Client |
+---------------------+ +-------------------+ +----------------+
| + createIterator() | | + next() | | 通过迭代器遍历聚合对象 |
+---------------------+ | + hasNext() | +----------------+ +-------------------+
角色说明
Aggregate：聚合接口，定义创建迭代器的方法（如createIterator()）。-
ConcreteAggregate：具体聚合类，实现迭代器创建逻辑。 Iterator：迭代器接口，定义遍历方法（如next()、hasNext()）。ConcreteIterator：具体迭代器，实现特定遍历逻辑。Client：通过迭代器访问聚合对象，无需依赖其内部结构。
3. 现代C++实现示例
场景：自定义链表迭代器
步骤1：定义链表节点与聚合类
#include <iostream>
#include <memory> template <typename T>
class ListNode {
public: T value; std::shared_ptr<ListNode<T>> next; ListNode(T val) : value(val), next(nullptr) {}
}; // 聚合类：单向链表
template <typename T>
class LinkedList {
public: void append(T value) { auto newNode = std::make_shared<ListNode<T>>(value); if (!head_) { head_ = newNode; } else { tail_->next = newNode; } tail_ = newNode; } // 创建正向迭代器 class Iterator; Iterator begin() { return Iterator(head_); } Iterator end() { return Iterator(nullptr); } private: std::shared_ptr<ListNode<T>> head_ = nullptr; std::shared_ptr<ListNode<T>> tail_ = nullptr;
};
步骤2：实现迭代器类
template <typename T>
class LinkedList<T>::Iterator {
public: Iterator(std::shared_ptr<ListNode<T>> node) : current_(node) {} T& operator*() const { return current_->value; } Iterator& operator++() { if (current_) current_ = current_->next; return *this; } bool operator!=(const Iterator& other) const { return current_ != other.current_; } private: std::shared_ptr<ListNode<T>> current_;
};
步骤3：客户端代码
int main() { LinkedList<int> list; list.append(1); list.append(2); list.append(3); // 使用范围for循环（依赖begin()和end()） for (auto num : list) { std::cout << num << " "; // 输出：1 2 3 } // 手动迭代 auto it = list.begin(); while (it != list.end()) { std::cout << *it << " "; ++it; }
}
扩展：反向迭代器
template <typename T>
class LinkedList<T>::ReverseIterator {
public: ReverseIterator(std::shared_ptr<ListNode<T>> head) { // 遍历链表，将节点指针存入栈以实现反向 auto curr = head; while (curr) { stack_.push(curr); curr = curr->next; } } T& operator*() { return stack_.top()->value; } ReverseIterator& operator++() { if (!stack_.empty()) stack_.pop(); return *this; } bool operator!=(const ReverseIterator& other) { return !stack_.empty() || !other.stack_.empty(); } private: std::stack<std::shared_ptr<ListNode<T>>> stack_;
};
4. 应用场景示例
场景1：树结构的深度优先遍历
class TreeNode {
public: int value; std::vector<std::shared_ptr<TreeNode>> children;
}; class DepthFirstIterator {
public: DepthFirstIterator(std::shared_ptr<TreeNode> root) { stack_.push(root); } std::shared_ptr<TreeNode> next() { auto node = stack_.top(); stack_.pop(); for (auto it = node->children.rbegin(); it != node->children.rend(); ++it) { stack_.push(*it); } return node; } bool hasNext() { return !stack_.empty(); } private: std::stack<std::shared_ptr<TreeNode>> stack_;
};
场景2：过滤迭代器（条件遍历）
template <typename T, typename Predicate>
class FilterIterator {
public: FilterIterator(typename LinkedList<T>::Iterator it, Predicate pred) : it_(it), pred_(pred) { // 找到第一个满足条件的元素 while (it_ != end_ && !pred_(*it_)) ++it_; } T& operator*() { return *it_; } FilterIterator& operator++() { do { ++it_; } while (it_ != end_ && !pred_(*it_)); return *this; } bool operator!=(const FilterIterator& other) { return it_ != other.it_; } private: typename LinkedList<T>::Iterator it_; typename LinkedList<T>::Iterator end_; Predicate pred_;
}; // 使用示例：遍历链表中的偶数
auto isEven = [](int x) { return x % 2 == 0; };
FilterIterator<int, decltype(isEven)> begin(list.begin(), isEven);
FilterIterator<int, decltype(isEven)> end(list.end(), isEven);
while (begin != end) { std::cout << *begin << " "; ++begin;
}
5. 优缺点分析
| 优点 | 缺点 |
|---|---|
| 解耦遍历逻辑与数据结构 | 增加类的数量（迭代器与聚合类需配对） |
| 支持多种遍历策略（正向、反向等） | 复杂数据结构迭代器实现成本高（如图遍历） |
| 隐藏聚合对象内部实现 | 部分语言/框架已内置迭代器（如STL） |
6. 调试与优化策略
调试技巧（VS2022）
1.验证迭代器有效性：
- 在迭代器越界时触发断言：
T& operator*() { assert(current_ != nullptr && "迭代器越界！"); return current_->value;
}
2. 检查迭代器状态：
- 在
operator++()中设置断点，观察指针移动是否符合预期。
性能优化
1. 预计算遍历路径：
- 对树或图的遍历，预计算路径并缓存结果（如广度优先遍历队列）。
2. 内存连续性优化：
- 使用std::vector存储节点，利用内存局部性提升遍历速度。
