（十六）迭代器模式

定义：迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。[DP]

UML:

举例：

例子描述，当一个表演团队要进入会场进行表演前，都需要查验入场证件，那么不管这个团队的人员身份如何，都需要按人头查验，如队员，教练，导演等。

那么就可以实现成迭代器的模式。

// Iterator.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <memory>
#include <vector>

using namespace std;

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

//聚集抽象类，用以创建迭代器
class Aggregate
{
public:
	virtual ~Aggregate(){}
	virtual Iterator * CreateIterator() = 0;
};

class ConCreteAggregate;
//具体的迭代器类
class ConcreteIterator : public Iterator
{
private:
	ConCreteAggregate *aggregate;
	int current;
public:
	ConcreteIterator(ConCreteAggregate *aggregate)
	: current(0)
	{
		this->aggregate = aggregate;
	}

	string First();//为了防止用到ConCreteAggregate的定义能容，这些接口的实现，改为作用域定义
	string Next();
	string CurrentItem();
	bool IsDone();
};

//具体的聚集类，用于创建迭代器
class ConCreteAggregate : public Aggregate
{
private:
	vector<string> vec;//这里使用string作为迭代的对象，实际业务中可能会使用类对象
public:
	Iterator *CreateIterator()
	{
		return new ConcreteIterator(this);
	}
	string operator[](int i)//重载了类的下表操作符
	{
		return vec[i];
	}
	void Insert(string str)
	{
		vec.push_back(str);
	}
	int count()
	{
		return vec.size();
	}
};

//与声明分离的具体迭代接口的实现
string ConcreteIterator::First(){return aggregate->operator[](0);}
string ConcreteIterator::Next()
{
	string str;
	++current;
	if (current < aggregate->count())
	{
		str = aggregate->operator[](current);
	}

	return str;
}
string ConcreteIterator::CurrentItem(){return aggregate->operator[](current);}
bool ConcreteIterator::IsDone(){return current >= aggregate->count();}

int _tmain(int argc, _TCHAR* argv[])
{
	ConCreteAggregate *a = new ConCreteAggregate; 
	a->Insert("队员1");//建立具体的迭代集合，并向其中插入要遍历的对象
	a->Insert("队员2");
	a->Insert("队员3");
	a->Insert("队长");
	a->Insert("教练");
	a->Insert("导演");

	//建立迭代器，并遍历检查证件
	Iterator * I = new ConcreteIterator(a);
	string str = I->First();
	while (!I->IsDone())
	{
		cout << "请出示进场证件！ 当前目标：" << I->CurrentItem().c_str() << endl;
		I->Next();
	}

	return 0;
}

输出：

上面，为了更好的封装迭代器，将要迭代的元素封装起来形成一个类似于仓库的类ConCreteAggregate，否则实现对元素的访问接口，而为了保证迭代器具有扩充性，定义了抽象类Iterator，这里实现了一种迭代器ConcreteIterator，从接口看，这个是顺序迭代器，如果要实现特殊类型迭代器，从Iterator继承即可，它声明了基本的遍历方法。

例如我想实现反序迭代器，来检查人员证件，那么就可以重新实现遍历接口如下：

//与声明分离的具体迭代接口的实现（逆序）
string ConcreteIterator::First()
{
	current = aggregate->count() - 1;
	return aggregate->operator[](aggregate->count() - 1); 
}
string ConcreteIterator::Next()
{
	string str;
	--current;
	if (current > 0)
	{
		str = aggregate->operator[](current);
	}

	return str;
}
string ConcreteIterator::CurrentItem(){return aggregate->operator[](current);}
bool ConcreteIterator::IsDone(){return current < 0;}

实习成这样对大家不是什么难事，输出结构就是反过来了：

总结：

应用场景：

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

2.你需要对聚集有多种遍历方式时，可以考虑使用迭代器模式。

3.为遍历不同的聚集结构提供如开始，下一个，是否结束，当前哪一项等统一接口