design pattern——iterator

model

implement

aggregate

class Iterator;
typedef int Object;

class Aggregate
{
protected:
    Aggregate();
    
public:
    virtual ~Aggregate();
    
public:
    virtual Iterator* CreateIterator() = 0;
    virtual Object GetItem(int idx) = 0;
    virtual int GetSize() = 0;
};

Aggregate::Aggregate()
{
}

Aggregate::~Aggregate()
{
}

concrete aggregate

class ConcreteAggregate : public Aggregate
{
public:
    enum {SIZE = 3};
    
public:
    ConcreteAggregate();
    ~ConcreteAggregate();
    
public:
    Iterator* CreateIterator();
    Object GetItem(int idx);
    int GetSize();
    
private:
    Object _objs[SIZE];
};

ConcreteAggregate::ConcreteAggregate()
{
    for(int i = 0; i < SIZE; ++i)
    {
        _objs[i] = i;
    }
}

ConcreteAggregate::~ConcreteAggregate()
{
}

Iterator* ConcreteAggregate::CreateIterator()
{
    return new ConcreteIterator(this);
}

Object ConcreteAggregate::GetItem(int idx)
{
    if(idx < GetSize())
    {
        return _objs[idx];
    }
    else
    {
        return -1;
    }
}

int ConcreteAggregate::GetSize()
{
    return SIZE;
}

iterator

typedef int Object;

class Iterator
{
protected:
    Iterator();
    
public:
    virtual ~Iterator();
    
public:
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() = 0;
    virtual Object CurrentItem() = 0;
};

Iterator::Iterator()
{
}

Iterator::~Iterator()
{
}

concrete iterator

class ConcreteIterator : public Iterator
{
public:
    ConcreteIterator(Aggregate* ag, int idx = 0);
    ~ConcreteIterator();
    
public:
    void First();
    void Next();
    bool IsDone();
    Object CurrentItem();
    
private:
    Aggregate* _ag;
    int _idx;
};

ConcreteIterator::ConcreteIterator(Aggregate* ag, int idx)
{
    _ag = ag;
    _idx = idx;
}

ConcreteIterator::~ConcreteIterator()
{
}

void ConcreteIterator::First()
{
    _idx = 0;
}

void ConcreteIterator::Next()
{
    if(_idx < _ag->GetSize())
    {
        _idx++;
    }
}

bool ConcreteIterator::IsDone()
{
    return _idx == _ag->GetSize();
}

Object ConcreteIterator::CurrentItem()
{
    return _ag->GetItem(_idx);
}

应用

void iterator_test()
{
    Aggregate* ag = new ConcreteAggregate();
    
    Iterator* iter = new ConcreteIterator(ag);
    
    for(iter->First(); !iter->IsDone(); iter->Next())
    {
        cout << iter->CurrentItem() << endl;
    }
}

总结

• 抽象：基类Aggregate和基类Iterator进行了抽象
• 扩展：concrete aggregate和concrete iterator可以进行扩展
• 开发者不需要知道concrete aggregate和concrete iterator，开发者只需要与基类Aggregate和基类Iterator交互