设计模式之迭代模式(Iterator)

优点：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示；

template<class Item>
class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual Item currentItem() = 0;
    virtual bool isDone() = 0;
    virtual ~Iterator(){}
};

template<class Item>
class ConcreteAggregate;

template<class Item>
class ConcreteIterator : public Iterator <Item>
{
public:
    ConcreteIterator(ConcreteAggregate<Item> *aggr):_aggre(aggr),_current(0){}

    void first()
    {
        _current = 0;
    }

    void next()
    {
        if(_current < _aggre->size())
            _current++;
    }

    Item currentItem()
    {
        if(_current < _aggre->size())
            return (*_aggre)[_current];
        return NULL;
    }

    bool isDone()
    {
        return (_current < _aggre->size());
    }
private:
    ConcreteAggregate<Item> *_aggre;
    int _current;
};

template <class Item>
class Aggregate
{
public:
    virtual Iterator<Item> *createIterator() = 0;
    virtual ~Aggregate(){}
};

template <class Item>
class ConcreteAggregate
{
public:
    ConcreteAggregate()
    {
    }

    Iterator<Item> *createIterator()
    {
        return new ConcreteIterator<Item>(this);
    }

    Item &operator [](int index)
    {
        return _data[index];
    }

    void add(Item item)
    {
        _data.push_back(item);
    }

    int size()
    {
        return _data.size();
    }

private:
    vector<Item> _data;
};

int main()
{
    ConcreteAggregate<int> *aggregate = new ConcreteAggregate<int>();
    aggregate->add(1);
    aggregate->add(2);
    aggregate->add(3);

    Iterator<int> *iterator = aggregate->createIterator();

    for(iterator->first(); iterator->isDone();iterator->next())
    {
        cout << iterator->currentItem() << endl;
    }

    system("pause");
    return 0;
}