【第22节】C++设计模式(行为模式)-Iterator(迭代器)模式

一、问题背景

        Iterator 模式是设计模式中最为常见和实用的模式之一。它的核心思想是将对聚合对象的遍历操作封装到一个独立的类中，从而避免暴露聚合对象的内部表示。通过 Iterator 模式，我们可以实现对聚合对象的统一遍历接口，而不需要关心聚合对象的具体实现细节。

        在实际开发中，Iterator 模式的应用非常广泛。例如，在实现 Composite 模式、Flyweight 模式、Observer 模式时，我们经常会使用 STL 提供的 Iterator 来遍历 `Vector` 或 `List` 等数据结构。Iterator 模式不仅简化了遍历操作，还提高了代码的可维护性和可扩展性。

二、模式选择

        Iterator 模式的典型结构图如下：

在 Iterator 模式中，主要包含以下几个角色：

（1）Aggregate（聚合）：定义创建 Iterator 对象的接口。
（2）ConcreteAggregate（具体聚合）：实现 Aggregate 接口，返回一个具体的 Iterator 实例。
（3）Iterator（迭代器）：定义遍历聚合对象的接口。
（4）ConcreteIterator（具体迭代器）：实现 Iterator 接口，负责遍历具体的聚合对象。

        通过这种设计，Iterator 模式将聚合对象的遍历逻辑与其内部实现分离，使得聚合对象可以独立于遍历逻辑进行修改。

三、代码实现

        下面我们将通过一个完整的 C++ 代码示例来展示如何实现 Iterator 模式。为了方便初学者的学习和参考，代码将包含详细的注释。

代码片段 1：Aggregate.h

// Aggregate.h
#ifndef _AGGREGATE_H_
#define _AGGREGATE_H_class Iterator;
typedef int Object;  // 定义聚合对象中存储的数据类型// Aggregate 类：定义创建 Iterator 对象的接口
class Aggregate {
public:virtual ~Aggregate();virtual Iterator* CreateIterator() = 0;  // 创建迭代器virtual Object GetItem(int idx) = 0;     // 获取指定位置的元素virtual int GetSize() = 0;               // 获取聚合对象的大小
protected:Aggregate();
private:
};// ConcreteAggregate 类：具体聚合类，实现 Aggregate 接口
class ConcreteAggregate : public Aggregate {
public:enum { SIZE = 3 };  // 定义聚合对象的大小ConcreteAggregate();~ConcreteAggregate();Iterator* CreateIterator();  // 创建迭代器Object GetItem(int idx);     // 获取指定位置的元素int GetSize();               // 获取聚合对象的大小
protected:
private:Object _objs[SIZE];  // 聚合对象中存储的数据
};#endif //~_AGGREGATE_H_

代码片段 2：Aggregate.cpp

// Aggregate.cpp
#include "Aggregate.h"
#include "Iterator.h"
#include <iostream>
using namespace std;// Aggregate 类的实现
Aggregate::Aggregate() {// 构造函数
}Aggregate::~Aggregate() {// 析构函数
}// ConcreteAggregate 类的实现
ConcreteAggregate::ConcreteAggregate() {// 初始化聚合对象中的数据for (int i = 0; i < SIZE; i++) {_objs[i] = i;}
}ConcreteAggregate::~ConcreteAggregate() {// 析构函数
}Iterator* ConcreteAggregate::CreateIterator() {// 创建具体的迭代器对象return new ConcreteIterator(this);
}Object ConcreteAggregate::GetItem(int idx) {// 获取指定位置的元素if (idx < this->GetSize()) {return _objs[idx];} else {return -1;  // 如果索引越界，返回 -1}
}int ConcreteAggregate::GetSize() {// 获取聚合对象的大小return SIZE;
}

代码片段 3：Iterator.h

// Iterator.h
#ifndef _ITERATOR_H_
#define _ITERATOR_H_class Aggregate;
typedef int Object;  // 定义聚合对象中存储的数据类型// Iterator 类：定义遍历聚合对象的接口
class Iterator {
public:virtual ~Iterator();virtual void First() = 0;          // 将迭代器指向第一个元素virtual void Next() = 0;           // 将迭代器指向下一个元素virtual bool IsDone() = 0;         // 判断是否遍历结束virtual Object CurrentItem() = 0;  // 获取当前元素
protected:Iterator();
private:
};// ConcreteIterator 类：具体迭代器类，实现 Iterator 接口
class ConcreteIterator : public Iterator {
public:ConcreteIterator(Aggregate* ag, int idx = 0);  // 构造函数~ConcreteIterator();void First();          // 将迭代器指向第一个元素void Next();           // 将迭代器指向下一个元素bool IsDone();         // 判断是否遍历结束Object CurrentItem();  // 获取当前元素
protected:
private:Aggregate* _ag;  // 聚合对象int _idx;        // 当前索引
};#endif //~_ITERATOR_H_

代码片段 4：Iterator.cpp

// Iterator.cpp
#include "Iterator.h"
#include "Aggregate.h"
#include <iostream>
using namespace std;// Iterator 类的实现
Iterator::Iterator() {// 构造函数
}Iterator::~Iterator() {// 析构函数
}// ConcreteIterator 类的实现
ConcreteIterator::ConcreteIterator(Aggregate* ag, int idx) {this->_ag = ag;  // 初始化聚合对象this->_idx = idx;  // 初始化当前索引
}ConcreteIterator::~ConcreteIterator() {// 析构函数
}Object ConcreteIterator::CurrentItem() {// 获取当前元素return _ag->GetItem(_idx);
}void ConcreteIterator::First() {// 将迭代器指向第一个元素_idx = 0;
}void ConcreteIterator::Next() {// 将迭代器指向下一个元素if (_idx < _ag->GetSize()) {_idx++;}
}bool ConcreteIterator::IsDone() {// 判断是否遍历结束return (_idx == _ag->GetSize());
}

代码片段 5：main.cpp

// main.cpp
#include "Iterator.h"
#include "Aggregate.h"
#include <iostream>
using namespace std;int main(int argc, char* argv[]) {// 创建聚合对象Aggregate* ag = new ConcreteAggregate();// 创建迭代器对象Iterator* it = ag->CreateIterator();// 遍历聚合对象for (; !(it->IsDone()); it->Next()) {cout << it->CurrentItem() << endl;}// 释放内存delete it;delete ag;return 0;
}

代码说明

（1）Aggregate 类：定义了创建 Iterator 对象的接口，并提供了获取聚合对象大小和元素的方法。
（2）ConcreteAggregate 类：实现了 Aggregate 接口，内部维护了一个固定大小的数组。
（3）Iterator 类：定义了遍历聚合对象的接口，包括移动到第一个元素、移动到下一个元素、判断是否遍历结束以及获取当前元素的方法。
（4）ConcreteIterator 类：实现了 Iterator 接口，负责遍历 ConcreteAggregate 对象。

 

四、总结讨论

        Iterator 模式的应用非常广泛，尤其是在需要对聚合对象进行遍历时。通过将遍历逻辑封装到独立的 Iterator 类中，我们可以实现以下优点：

（1）简化遍历操作：客户端代码只需要调用 Iterator 的接口即可完成遍历，无需关心聚合对象的内部实现。
（2）提高代码复用性：可以为不同的聚合对象提供统一的遍历接口。
（3）增强灵活性：可以在不修改聚合对象的情况下，扩展或修改遍历逻辑。

        在实际开发中，STL 提供的 Iterator 就是一个典型的应用。例如，我们可以使用 `std::vector<int>::iterator` 来遍历 `std::vector<int>`，而无需关心 `std::vector` 的内部实现。

        Iterator 模式通过将对聚合对象的遍历操作封装到独立的类中，实现了遍历逻辑与聚合对象的解耦。这种设计模式不仅简化了代码结构，还提高了代码的可维护性和可扩展性。在实际开发中，Iterator 模式是处理聚合对象遍历问题的首选方案。