24.迭代器模式--Iterator

 

Iterator模式：
Iterator模式太常见了，在使用STL中就免不了要使用迭代器。Iterator提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑使用迭代器模式。Iterator模式分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明的访问集合内部的数据。

Iterator模式典型的结构图为：
 

Iterator的实现代码如下：

//Aggregate.h
#ifndef _AGGREGATE_H_
#define _AGGREGATE_H_
class Iterator;
typedef int Object;
class Interator;
class Aggregate
{
public:
    virtual ~Aggregate();
    virtual Iterator* CreateIterator() = 0;
    virtual Object GetItem(int idx) = 0;
    virtual int GetSize() = 0;
protected:
    Aggregate();
private:
};
class ConcreteAggregate:public Aggregate
{
public:
    enum {SIZE = 3};
    ConcreteAggregate();
    ~ConcreteAggregate();
    Iterator* CreateIterator();
    Object GetItem(int idx);
    int GetSize();
protected:
private:
    Object _objs[SIZE];
};
#endif //~_AGGREGATE_H_

//Aggregate.cpp
#include "Aggregate.h"
#include "Iterator.h"
#include <iostream>
using namespace std;
Aggregate::Aggregate()
{
}
Aggregate::~Aggregate()
{
}
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 < this->GetSize())
        return _objs[idx];
    else
        return -1;
}
int ConcreteAggregate::GetSize()
{
    return SIZE;
}

//Iterator.h
#ifndef _ITERATOR_H_
#define _ITERATOR_H_
class Aggregate;
typedef int Object;
class Iterator
{
public:
    virtual ~Iterator();
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() = 0;
    virtual Object CurrentItem() = 0;
protected:
    Iterator();
private:
};
class ConcreteIterator:public Iterator
{
public:
    ConcreteIterator(Aggregate* ag , int idx = 0);
    ~ConcreteIterator();
    void First();
    void Next();
    bool IsDone();
    Object CurrentItem();
protected:
private:
    Aggregate* _ag;
    int _idx;
};
#endif //~_ITERATOR_H_

//Iterator.cpp
#include "Iterator.h"
#include "Aggregate.h"
#include <iostream>
using namespace std;
Iterator::Iterator()
{
}
Iterator::~Iterator()
{
}
ConcreteIterator::ConcreteIterator(Aggregate*
                                   ag , int idx)
{
    this->_ag = ag;
    this->_idx = idx;
}
ConcreteIterator::~ConcreteIterator()
{
}
Object ConcreteIterator::CurrentItem()
{
    return _ag->GetItem(_idx);
}
void ConcreteIterator::First()
{
    _idx = 0;
}
void ConcreteIterator::Next()
{
    if (_idx < _ag->GetSize())
        _idx++;
}
bool ConcreteIterator::IsDone()
{
    return (_idx == _ag->GetSize());
}

//main.cpp
#include "Iterator.h"
#include "Aggregate.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{
    Aggregate* ag = new ConcreteAggregate();
    Iterator* it = new ConcreteIterator(ag);

    for (; !(it->IsDone()) ; it->Next())
    {
        cout<<it->CurrentItem()<<endl;
    }
    return 0;
}