迭代器模式 (Iterator Pattern)

迭代器模式 (Iterator Pattern)

意图：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

基础组件

• Iterator (迭代器)：定义访问和遍历元素的接口
• ConcreteIterator (具体迭代器)：实现迭代器接口，跟踪当前位置
• Aggregate (聚合)：定义创建迭代器对象的接口
• ConcreteAggregate (具体聚合)：实现聚合接口，返回具体迭代器实例

继承/实现关系

Iterator <|-- ConcreteIterator
Aggregate <|-- ConcreteAggregate
ConcreteAggregate --> ConcreteIterator (创建)
ConcreteIterator --> ConcreteAggregate (访问元素)

应用场景

• 需要访问聚合对象的内容而不暴露其内部结构
• 需要支持多种遍历方式
• 需要为不同聚合结构提供统一遍历接口

C++ 实现（自定义集合迭代器）

#include <iostream>
#include <string>
#include <vector>
#include <memory>

/*
* 迭代器模式
* 意图：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。
* 基础组件：
* Iterator (迭代器)：定义访问和遍历元素的接口
* ConcreteIterator (具体迭代器)：实现迭代器接口，跟踪当前位置
* Aggregate (聚合)：定义创建迭代器对象的接口
* ConcreteAggregate (具体聚合)：实现聚合接口，返回具体迭代器实例
* 继承/实现关系：
* ConcreteIterator 继承自 Iterator
* ConcreteAggregate 继承自 Aggregate
* ConcreteAggregate 负责 ConcreteIterator 的创建
* ConcreteIterator 能够按序访问 ConcreteAggregate 中的元素
*/

// 迭代器接口
template <typename T>
class Iterator {
public:
    /*
	* 迭代器接口需要提供基本的迭代功能：
	* first, next, isDone, currentItem
    */
    virtual ~Iterator() = default;
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const = 0;
    virtual T currentItem() const = 0;
};

// 聚合接口，能够给外部返回一个迭代器实例来进行聚合内元素的访问（这里只是保证了迭代器模式的使用，具体业务逻辑应当在具体的实现类中）
template <typename T>
class Aggregate {
public:
    virtual ~Aggregate() = default;
    virtual std::unique_ptr<Iterator<T>> createIterator() = 0;
};

// 具体聚合：整数集合（具体实现类，包含具体的业务逻辑，同时能够返回一个迭代器实例）
class IntegerCollection : public Aggregate<int> {
public:
    void add(int num) {
        data_.push_back(num);
    }

    int get(int index) const {
        return data_[index];
    }

    int size() const {
        return static_cast<int>(data_.size());
    }

    std::unique_ptr<Iterator<int>> createIterator() override;

private:
    std::vector<int> data_;
};

// 具体迭代器：整数集合迭代器
class IntegerIterator : public Iterator<int> {
public:
    explicit IntegerIterator(const IntegerCollection* collection)
        : collection_(collection), current_(0) {}

    void first() override {
        current_ = 0;
    }

    void next() override {
        current_++;
    }

    bool isDone() const override {
        return current_ >= collection_->size();
    }

    int currentItem() const override {
        return collection_->get(current_);
    }

private:
    const IntegerCollection* collection_;
    int current_;
};

std::unique_ptr<Iterator<int>> IntegerCollection::createIterator() {
    return std::make_unique<IntegerIterator>(this);
}


void IteratorPattern()
{
	std::cout << std::string(13, '-') << " Iterator Pattern " << std::string(13, '-') << "\n";

    IntegerCollection collection;
    collection.add(1);
    collection.add(2);
    collection.add(3);
    collection.add(4);
    collection.add(5);

    auto it = collection.createIterator();
    for (it->first(); !it->isDone(); it->next()) {
        std::cout << it->currentItem() << " ";
    }
    std::cout << "\n";
}

组件对应关系

• Iterator<int> → 迭代器接口
• IntegerIterator → 具体迭代器
• Aggregate<int> → 聚合接口
• IntegerCollection → 具体聚合