当前位置：首页 > article >正文

C++实现设计模式---迭代器模式 (Iterator)

article 2025/1/20 3:14:41

迭代器模式 (Iterator)

迭代器模式 是一种行为型设计模式，它提供了一种方法，顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

意图

提供一种方法，可以顺序访问一个容器对象中的元素，而无需暴露其内部实现。
将遍历行为从集合对象中分离出来，使得遍历行为可以独立变化。

使用场景

需要顺序访问一个聚合对象中的元素：
- 如数组、链表或集合。
需要支持多种遍历方式：
- 如正序遍历、反序遍历等。
需要解耦遍历算法和容器实现：
- 容器的内部结构可能经常变化，但不希望影响遍历逻辑。

参与者角色

迭代器接口 (Iterator)
- 定义用于访问聚合对象元素的方法。
具体迭代器 (ConcreteIterator)
- 实现迭代器接口，提供对聚合对象的具体遍历。
聚合接口 (Aggregate)
- 定义创建迭代器的方法。
具体聚合类 (ConcreteAggregate)
- 实现聚合接口，提供一个数据集合并创建相应的迭代器。

示例代码

以下代码展示了迭代器模式的实现，用于模拟对一个数字集合的顺序访问。

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

// 迭代器接口
template <typename T>
class Iterator {
public:
    virtual ~Iterator() = default;

    // 获取下一个元素
    virtual T next() = 0;

    // 判断是否还有下一个元素
    virtual bool hasNext() const = 0;
};

// 聚合接口
template <typename T>
class Aggregate {
public:
    virtual ~Aggregate() = default;

    // 创建迭代器
    virtual std::unique_ptr<Iterator<T>> createIterator() const = 0;
};

// 具体迭代器
template <typename T>
class ConcreteIterator : public Iterator<T> {
private:
    const std::vector<T>& collection; // 引用聚合对象
    size_t index;                     // 当前索引

public:
    explicit ConcreteIterator(const std::vector<T>& collection)
        : collection(collection), index(0) {}

    T next() override {
        return collection[index++];
    }

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

// 具体聚合类
template <typename T>
class ConcreteAggregate : public Aggregate<T> {
private:
    std::vector<T> collection; // 存储元素的集合

public:
    void add(const T& element) {
        collection.push_back(element);
    }

    std::unique_ptr<Iterator<T>> createIterator() const override {
        return std::make_unique<ConcreteIterator<T>>(collection);
    }
};

// 客户端代码
int main() {
    // 创建一个具体聚合对象
    ConcreteAggregate<int> aggregate;
    aggregate.add(1);
    aggregate.add(2);
    aggregate.add(3);
    aggregate.add(4);
    aggregate.add(5);

    // 获取迭代器
    auto iterator = aggregate.createIterator();

    // 遍历聚合对象
    std::cout << "集合中的元素: ";
    while (iterator->hasNext()) {
        std::cout << iterator->next() << " ";
    }
    std::cout << "
";

    return 0;
}

代码解析

1. 迭代器接口 (Iterator)

定义了 next 和 hasNext 方法，用于访问聚合对象中的元素。
子类需要实现这些方法以提供具体的遍历逻辑。

template <typename T>
class Iterator {
public:
    virtual ~Iterator() = default;
    virtual T next() = 0;
    virtual bool hasNext() const = 0;
};

2. 具体迭代器 (ConcreteIterator)

实现了迭代器接口。
使用内部索引 index 记录当前遍历的位置，并提供 next 和 hasNext 方法。

template <typename T>
class ConcreteIterator : public Iterator<T> {
private:
    const std::vector<T>& collection;
    size_t index;
public:
    explicit ConcreteIterator(const std::vector<T>& collection)
        : collection(collection), index(0) {}
    T next() override { return collection[index++]; }
    bool hasNext() const override { return index < collection.size(); }
};

3. 聚合接口 (Aggregate)

定义了 createIterator 方法，用于创建迭代器。

template <typename T>
class Aggregate {
public:
    virtual ~Aggregate() = default;
    virtual std::unique_ptr<Iterator<T>> createIterator() const = 0;
};

4. 具体聚合类 (ConcreteAggregate)

存储数据集合，并实现了 createIterator 方法，返回具体的迭代器实例。

template <typename T>
class ConcreteAggregate : public Aggregate<T> {
private:
    std::vector<T> collection;
public:
    void add(const T& element) { collection.push_back(element); }
    std::unique_ptr<Iterator<T>> createIterator() const override {
        return std::make_unique<ConcreteIterator<T>>(collection);
    }
};

5. 客户端代码

客户端通过聚合对象获取迭代器，并通过迭代器访问集合中的元素。

int main() {
    ConcreteAggregate<int> aggregate;
    aggregate.add(1);
    aggregate.add(2);
    aggregate.add(3);

    auto iterator = aggregate.createIterator();
    while (iterator->hasNext()) {
        std::cout << iterator->next() << " ";
    }
}