如何在 c++++ 中实现迭代器设计模式？定义纯虚基类 iterator 作为迭代器抽象；创建 concreteiterator 具体实现，提供遍历容器元素的接口；定义纯虚基类 aggregate 作为聚合抽象；创建 concreteaggregate 具体实现，提供创建迭代器的接口；在 main 函数中，创建聚合对象，获取迭代器，并遍历容器中的元素。

如何在 C++ 中实现迭代器设计模式

迭代器设计模式允许你遍历容器对象中的元素，而无需了解它们的底层实现。

代码实现

以下是 C++ 中迭代器的代码实现：

#include <iostream>
#include <vector>

class Iterator {
public:
    virtual ~Iterator() {}
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() const = 0;
    virtual Iterator* Clone() const = 0;
    virtual std::string Current() const = 0;
};

class ConcreteIterator : public Iterator {
public:
    ConcreteIterator(const std::vector<std::string>& aggregate)
        : aggregate_(aggregate), index_(0) {}

    void First() override { index_ = 0; }
    void Next() override { ++index_; }
    bool IsDone() const override { return index_ == aggregate_.size(); }
    Iterator* Clone() const override { return new ConcreteIterator(*this); }
    std::string Current() const override { return aggregate_[index_]; }

private:
    const std::vector<std::string>& aggregate_;
    int index_;
};

class Aggregate {
public:
    Aggregate() {}
    virtual Iterator* CreateIterator() const = 0;
    virtual int Size() const = 0;
};

class ConcreteAggregate : public Aggregate {
public:
    ConcreteAggregate(const std::vector<std::string>& items) : items_(items) {}

    Iterator* CreateIterator() const override { return new ConcreteIterator(items_); }
    int Size() const override { return items_.size(); }

private:
    std::vector<std::string> items_;
};

int main() {
    std::vector<std::string> items = {"Item 1", "Item 2", "Item 3"};
    ConcreteAggregate aggregate(items);

    Iterator* iterator = aggregate.CreateIterator();

    for (iterator->First(); !iterator->IsDone(); iterator->Next()) {
        std::cout << iterator->Current() << std::endl;
    }

    return 0;
}

实战案例

此代码演示了如何使用迭代器模式来遍历一个字符串容器。它创建了 ConcreteAggregate 和 ConcreteIterator 两个类，分别充当聚合类和迭代器类。

在 main 函数中，我们创建 Vector 容器并使用 CreateIterator() 方法获取其迭代器。然后，我们可以使用迭代器来遍历容器中的元素并打印它们。