19.迭代器模式（Iterator Pattern）

定义

迭代器模式（Iterator Pattern） 是一种行为型设计模式，它提供了一种方法，使得可以顺序访问一个集合对象中的元素，而无需暴露集合对象的内部结构。通过迭代器模式，客户端可以通过统一的接口遍历容器中的元素，无论容器的具体实现如何。

特性

• 迭代器接口：定义了对容器对象进行遍历的公共接口，通常提供 next()、hasNext()、currentItem() 等方法。
• 容器对象：包含一个可以被迭代的集合（如数组、列表、队列等）。
• 客户端：通过迭代器接口来遍历容器对象中的元素，而无需直接操作容器的结构。

场景

适用场景：

• 需要遍历集合中的元素：当你需要访问集合中的元素，但不希望暴露集合的具体实现时，迭代器模式是一种理想的选择。
• 容器对象结构复杂：当容器对象的结构非常复杂（如双向链表、树形结构等）时，迭代器模式可以帮助简化遍历过程。
• 多个遍历方式：当你希望为同一个集合提供不同的遍历方式时，可以通过不同的迭代器实现来满足不同的需求。
• 容器元素的遍历需要与集合分离：当你希望容器的内部结构与遍历操作解耦时，迭代器模式是一个理想的选择。

应用场景

• 遍历数据结构：如链表、树、图等数据结构的遍历。
• 数据库查询结果的遍历：对于从数据库中查询出的数据集，迭代器可以作为访问这些数据的方式。
• UI组件的遍历：在GUI系统中，容器对象（如面板、列表等）中的元素需要被逐一遍历并操作。

类设计

迭代器模式通常包括以下几个角色：

1. Iterator（迭代器）：定义了遍历集合的接口，通常包含 hasNext()、next() 等方法。
2. ConcreteIterator（具体迭代器）：实现了 Iterator 接口，提供具体的遍历逻辑。
3. Aggregate（集合接口）：定义了集合的接口，通常包含 createIterator() 方法，返回一个迭代器实例。
4. ConcreteAggregate（具体集合）：实现了 Aggregate 接口，提供一个集合对象和相应的迭代器。

代码实现解析

我们通过设计一个 集合类（MyList） 和 迭代器（MyIterator） 来演示迭代器模式。在这个示例中，MyList 是一个容器，MyIterator 是迭代器，它将用于遍历集合中的元素。

1. 定义迭代器接口（Iterator）

#include 
#include 
using namespace std;

// 迭代器接口
template <typename T>
class Iterator {
public:
    virtual bool hasNext() = 0;  // 判断是否还有下一个元素
    virtual T next() = 0;        // 获取下一个元素
    virtual ~Iterator() {}
};

• Iterator 是迭代器接口，定义了遍历集合的两个关键方法：hasNext() 和 next()。

2. 定义集合接口（Aggregate）

template <typename T>
class Aggregate {
public:
    virtual Iterator<T>* createIterator() = 0;  // 创建迭代器
    virtual ~Aggregate() {}
};

• Aggregate 是集合接口，定义了一个方法 createIterator()，该方法返回一个迭代器对象。

3. 定义具体迭代器（ConcreteIterator）

template <typename T>
class MyIterator : public Iterator<T> {
private:
    vector<T>& data;
    int index;

public:
    MyIterator(vector<T>& data) : data(data), index(0) {}

    bool hasNext() override {
        return index < data.size();
    }

    T next() override {
        if (hasNext()) {
            return data[index++];
        }
        throw out_of_range("No more elements");
    }
};

• MyIterator 是具体迭代器，继承了 Iterator 接口，实现了遍历集合的方法。
• hasNext() 判断当前索引是否小于集合的大小。
• next() 返回当前索引位置的元素，并递增索引。

4. 定义具体集合类（ConcreteAggregate）

template <typename T>
class MyList : public Aggregate<T> {
private:
    vector<T> items;

public:
    void addItem(const T& item) {
        items.push_back(item);  // 向集合中添加元素
    }

    Iterator<T>* createIterator() override {
        return new MyIterator<T>(items);  // 返回一个迭代器
    }
};

• MyList 是具体集合类，提供了 addItem() 方法向集合中添加元素。
• createIterator() 方法返回一个新的 MyIterator 对象，允许客户端遍历集合中的元素。

5. 客户端调用

int main() {
    MyList<int> list;
    list.addItem(1);
    list.addItem(2);
    list.addItem(3);

    Iterator<int>* iterator = list.createIterator();
    while (iterator->hasNext()) {
        cout << iterator->next() << " ";  // 依次输出集合中的元素
    }
    cout << endl;

    delete iterator;  // 释放迭代器内存
    return 0;
}

6. 输出结果

1 2 3

• 在客户端代码中，首先创建了一个 MyList 类型的集合，并向其中添加了元素。
• 然后通过 createIterator() 创建了一个迭代器对象，使用迭代器逐个遍历并输出集合中的元素。

迭代器模式的优缺点

优点：

• 简化遍历过程：迭代器模式为遍历集合提供了一个统一的接口，隐藏了集合的实现细节，简化了遍历过程。
• 解耦：集合对象和客户端的遍历逻辑解耦，客户端不需要关心集合的内部结构。
• 支持多种遍历方式：可以为同一个集合对象提供不同的遍历方式，如顺序遍历、倒序遍历等。

缺点

• 增加了类的数量：为了实现迭代器模式，需要为每个集合定义一个对应的迭代器类，可能导致类的数量增加。
• 性能开销：对于某些简单的集合类型（如数组），使用迭代器模式可能会引入不必要的性能开销。

场景

适用场景：

• 容器元素的遍历：当需要遍历容器中的元素时，尤其是当容器类型复杂（如链表、树、图等）时，迭代器模式能够简化遍历的过程。
• 多种遍历方式：当同一个容器需要支持多种遍历方式（如顺序遍历、逆序遍历、深度优先遍历等）时，迭代器模式可以为不同的遍历方式提供独立的迭代器。
• 不暴露容器内部结构：当你不希望客户端直接操作容器的内部结构时，可以通过迭代器模式来控制访问方式。

编程相关的案例：

1. 文件遍历：在处理文件系统时，可能有多种类型的文件（如文本文件、图片文件等），通过迭代器模式可以为文件系统提供一个统一的遍历接口，使得不同类型的文件都可以被统一遍历。
2. 数据库查询结果遍历：从数据库查询结果中提取数据时，使用迭代器模式可以避免客户端直接操作查询结果集，使得数据的遍历更加简洁。
3. UI组件遍历：在GUI框架中，窗口可能包含多个子组件（如按钮、文本框等），通过迭代器模式可以统一遍历和处理这些子组件。

总结

迭代器模式通过提供一个统一的接口来遍历集合中的元素，使得客户端不需要关心集合的具体实现。它简化了容器元素的访问过程，增强了容器和客户端之间的解耦性。迭代器模式适用于需要遍历复杂数据结构、支持多种遍历方式且希望避免暴露内部实现细节的场景。