【大话设计设计模式】——迭代器模式Iterator

1、是什么？
    迭代器模式，提供一种方法顺序访问一个聚合对象中各元素，而不暴露该对象内部表示。

2、为什么？何时？
    当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑使用迭代器模式。

3、怎么用？


4、示例代码

#include <iostream>

using namespace std;

class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isTail() = 0;
    virtual int current() = 0;

};
class Aggregate
{
public:
    virtual Iterator* CreateIterator() = 0;
    virtual int getItem(int num) = 0;
    virtual int getSize() = 0;
};
class ConCreteIterator : public Iterator
{
public:
    ConCreteIterator()
    {
    }
    ConCreteIterator(Aggregate* agg)
    {
        pAgg = agg;
        index = 0;
    }
    void first()
    {
        index = 0;
    }
    void next()
    {
        if (index < pAgg->getSize())
        {
            index ++;
        }
    }
    bool isTail()
    {
        bool rt = (index == pAgg->getSize()-1);
        return rt;
    }
    int current()
    {
        if (index < pAgg->getSize()-1)
        {
            return pAgg->getItem(index);
        }
        return -1;
    }
private:
    Aggregate* pAgg;
    int index;
};

class ConcreteAggregate : public Aggregate
{
public:
    enum{SIZE = 3};
    ConcreteAggregate()
    {
        int i;
        for (i = 0; i < SIZE; i++)
        {
            data[i] = i;
        }
    }
    Iterator* CreateIterator()
    {
        return new ConCreteIterator();
    }
    int getItem(int num)
    {
        if (num < SIZE && num >= 0)
        {
            return data[num];
        }
        return -1;
    }
    int getSize()
    {
        return SIZE;
    }
private:
    int data[SIZE];
};

void main()
{
    cout<<"hello world\n";

    Aggregate* agg = new ConcreteAggregate();
    Iterator* itr = new ConCreteIterator(agg);
    for ( ; !(itr->isTail()); itr->next())
    {
        cout<<itr->current()<<endl;
    }
}