迭代器模式

一，简介

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

二，角色

Aggregate

聚集抽象类

ConcreteAggregate

具体聚集类

Iterator

迭代抽象类，用于定义得到开始对象、得到下一个对象、判断是否到结尾、当前对象等抽象方法，统一接口

ConcreteIterator

具体迭代器类

三，举例

1，类图

2，代码

using namespace std;

//迭代器抽象类
class Iterator {
public:
	Iterator(){}
	virtual ~Iterator() {}

	virtual string First() = 0;
	virtual string Next() = 0;
	virtual string GetCur() = 0;
	virtual bool IsEnd() = 0;
};

//聚集抽象类
class Aggregate {
public:
	virtual int Count() = 0;
	virtual void Push(const string& strValue) = 0;
	virtual string Pop(const int nIndex) = 0;
	virtual Iterator* CreateIterator() = 0;
};

//具体迭代器类
class ConcreteIterator :public Iterator {
public:
	ConcreteIterator(Aggregate* pAggregate) :m_nCurrent(0), Iterator() {
		m_Aggregate = pAggregate;
	}
	string First() {
		return m_Aggregate->Pop(0);
	}

	string Next() {
		string strRet;
		m_nCurrent++;
		if (m_nCurrent < m_Aggregate->Count()) {
			strRet = m_Aggregate->Pop(m_nCurrent);
		}
		return strRet;
	}
	string GetCur() {
		return m_Aggregate->Pop(m_nCurrent);
	}

	bool IsEnd() {
		return ((m_nCurrent >= m_Aggregate->Count()) ? true : false);
	}

private:
	Aggregate* m_Aggregate;
	int m_nCurrent;
};

//具体聚集类
class ConcreteAggregate :public Aggregate {
public:
	ConcreteAggregate() :m_pIterator(NULL) {
		m_vecItems.clear();
	}
	~ConcreteAggregate()
	{
		if (NULL != m_pIterator) {
			delete m_pIterator;
			m_pIterator = NULL;
		}
	}
	Iterator* CreateIterator() {
		if (NULL == m_pIterator) {
			m_pIterator = new ConcreteIterator(this);
		}
		return m_pIterator;
	}
	int Count() {
		return m_vecItems.size();
	}
	void Push(const string& strValue) {
		m_vecItems.push_back(strValue);
	}
	string Pop(const int nIndex) {
		string strRet;
		if (nIndex < Count()) {
			strRet = m_vecItems[nIndex];
		}
		return strRet;
	}

private:
	vector<string> m_vecItems;
	Iterator* m_pIterator;
};

int main()
{
	ConcreteAggregate* pName = new  ConcreteAggregate();
	pName->Push("A");
	pName->Push("B");
	pName->Push("C");
	pName->Push("D");

	Iterator* iter = pName->CreateIterator();
	string  strItem = iter->First();
	while (!iter->IsEnd())
	{
		cout << iter->GetCur() << endl;
		iter->Next();
	}

	system("pause");
	return 0;
}

四，优缺点

优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

五，使用场景

 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。

注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。高级语言已经内置了迭代器相关接口。

使用迭代器的好处是：for和foreach都需要先知道集合的类型，甚至是集合内元素的类型，即需要访问内部的成员，不能实现多态；iterator是一个接口类型，他不关心集合或者数组的类型，而且他还能随时修改和删除集合的元素.