在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