iterator design pattern.cpp

#include <iostream>
#include <vector>
using namespace std;

// Iterator Interface
class Iterator {
public:
    virtual int next() = 0;
    virtual bool hasNext() const = 0;
    virtual ~Iterator() = default;
};

// Concrete Iterator
class ConcreteIterator : public Iterator {
private:
    const vector<int>& collection;
    size_t index;

public:
    ConcreteIterator(const vector<int>& collection) : collection(collection) {
        index = 0;
    }

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

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

// Aggregate Interface
class Aggregate {
public:
    virtual Iterator* createIterator() const = 0;
    virtual ~Aggregate() = default;
};

// Concrete Aggregate
class ConcreteAggregate : public Aggregate {
private:
    vector<int> collection;

public:
    void add(int item) {
        collection.push_back(item);
    }

    Iterator* createIterator() const override {
        return new ConcreteIterator(collection);
    }
};

// Client code
int main() {
    ConcreteAggregate aggregate;
    aggregate.add(1);
    aggregate.add(2);
    aggregate.add(3);
    aggregate.add(4);
    aggregate.add(5);

    Iterator* iterator = aggregate.createIterator();
    while (iterator->hasNext()) {
        cout << iterator->next() << " ";
    }
    cout << endl;

    delete iterator;
    return 0;
}