[设计模式] 16 迭代器模式 Iterator Pattern

在GOF的《设计模式:可复用面向对象软件的基础》一书中对迭代器模式是这样说的：提供一种方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示。

类图和实例：

迭代器模式由以下角色组成：

1．迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。
2．具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。
3．集合角色（Aggregate）：集合角色负责提供创建具体迭代器角色的接口。
4．具体集合角色（Concrete Aggregate）：具体集合角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该集合的结构相关。

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

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

template<class Item>
class ConcreteAggregate;

template<class Item>
class ConcreteIterator : public Iterator <Item>
{
    ConcreteAggregate<Item> * aggr;
    int cur;
public:
    ConcreteIterator(ConcreteAggregate<Item>*a):aggr(a),cur(){}
    virtual void first()
    {
        cur=;
    }
    virtual void next()
    {
        if(cur<aggr->getLen())
            cur++;
    }
    virtual Item* currentItem()
    {
        if(cur<aggr->getLen())
            return &(*aggr)[cur];
        else
            return NULL;
    }
    virtual bool isDone()
    {
        return (cur>=aggr->getLen());
    }
};

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

template<class Item>
class ConcreteAggregate:public Aggregate<Item>
{
    vector<Item >data;
public:
    ConcreteAggregate()
    {
        data.push_back();
        data.push_back();
        data.push_back();
    }
    virtual Iterator<Item>* createIterator()
    {
        return new ConcreteIterator<Item>(this);
    }
    Item& operator[](int index)
    {
        return data[index];
    }
    int getLen()
    {
        return data.size();
    }
};

int main()
{
    Aggregate<int> * aggr =new ConcreteAggregate<int>();
    Iterator<int> *it=aggr->createIterator();

    for(it->first();!it->isDone();it->next())
    {
        cout<<*(it->currentItem())<<endl;
    }
    delete it;
    delete aggr;
    return ;
}

实现要点：

1．迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

2．迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

3．迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。

适用性：

1．访问一个聚合对象的内容而无需暴露它的内部表示。

2．支持对聚合对象的多种遍历。

3．为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

其他：

1．在C++下可以参看 STL iterators 的实现。

转：http://blog.csdn.net/lcl_data/article/details/9310313