设计模式-迭代器模式

定义

迭代器模式是一种行为型设计模式，它提供一种按顺序访问聚合对象中的元素的方法，而又无须暴露聚合对象的内部表示。迭代器模式通过将集合对象的迭代行为抽象到迭代器中，提供一致的接口，使得不同的容器可以提供一致的遍历行为。

在迭代器模式中，主要涉及以下角色：

抽象迭代器（Iterator）：负责定义访问和遍历元素的接口。
具体迭代器（ConcreteIterator）：提供具体的元素遍历方法。
抽象容器（IAggregate）：负责定义提供具体迭代器的接口。
具体容器（ConcreteAggregate）：创建具体迭代器。

使用迭代器模式可以方便地遍历容器，同时容器类型的改变对整体的影响较小。此外，迭代器模式还具有较好的封装性，将对象的内部结构和遍历过程都封装在迭代器中。然而，如果只是简单地遍历一个数组或其他简单的数据结构，使用for循环可能更为方便。

实现举例

当然可以！以下是一个使用C++实现的迭代器模式的示例：

cpp 复制代码

#include <iostream>
#include <vector>

// 抽象迭代器
class Iterator {
public:
    virtual bool hasNext() const = 0;
    virtual int next() = 0;
};

// 具体迭代器
class ConcreteIterator : public Iterator {
private:
    int current_;
    const std::vector<int>& data_;
public:
    ConcreteIterator(const std::vector<int>& data) : current_(0), data_(data) {}
    bool hasNext() const override {
        return current_ < data_.size();
    }
    int next() override {
        if (hasNext()) {
            return data_[current_++];
        } else {
            throw std::out_of_range("No more elements");
        }
    }
};

// 抽象容器
class Aggregate {
public:
    virtual Iterator* createIterator() const = 0;
};

// 具体容器
class ConcreteAggregate : public Aggregate {
private:
    std::vector<int> data_;
public:
    ConcreteAggregate(const std::vector<int>& data) : data_(data) {}
    Iterator* createIterator() const override {
        return new ConcreteIterator(data_);
    }
};

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    ConcreteAggregate aggregate(data);
    Iterator* iterator = aggregate.createIterator();
    while (iterator->hasNext()) {
        std::cout << iterator->next() << " ";
    }
    std::cout << std::endl;
    delete iterator; // 释放迭代器对象内存
    return 0;
}

总结

迭代器模式的主要特性包括：

访问聚合对象的内容而无需暴露其内部表示。
为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。
遍历任务交由迭代器完成，这简化了聚合类。
支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
增加新的聚合类和迭代器类都很方便，无须修改原有代码。
封装性良好，为遍历不同的聚合结构提供一个统一的接口。