迭代器模式

迭代器模式简单实现

UML类图：

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

● Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
● ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。
● Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
● ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。
在迭代器模式中，提供了一个外部的迭代器来对聚合对象进行访问和遍历，迭代器定义了一个访问该聚合元素的接口，并且可以跟踪当前遍历的元素，了解哪些元素已经遍历过而哪些没有。迭代器的引入，将使得对一个复杂聚合对象的操作变得简单。
下面我们结合代码来对迭代器模式的结构进行进一步分析。在迭代器模式中应用了工厂方法模式，抽象迭代器对应于抽象产品角色，具体迭代器对应于具体产品角色，抽象聚合类对应于抽象工厂角色，具体聚合类对应于具体工厂角色。

迭代器模式优缺点：

1. 主要优点
(1) 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
(2) 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
(3) 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

2. 主要缺点
迭代器模式的主要缺点如下：
(1) 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
(2) 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

迭代器模式适用场景：
(1) 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。
(2) 需要为一个聚合对象提供多种遍历方式。
(3) 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。

<span style="font-size:18px;">#pragma once
#ifndef  _AGGREGATE_H_
#define _AGGREGATE_H_
#include<string>
#include<vector>
#include<cassert>
using std::vector;
using std::string;
class Iterator;
typedef string Object;
//抽象聚合类
class Aggregate
{
public:
	Aggregate()
	{}
	~Aggregate()
	{}
	virtual Object& GetItem(const int Idx) = 0;
	virtual Object& operator[](const int Idx) = 0;
	virtual void Add(const Object& Obj) = 0;
	virtual void Remove() = 0;
	virtual int Size()const=0;
	virtual bool Empty()const=0;
};

//具体聚合类
class ConCreateAggregate :public Aggregate
{
public:
	ConCreateAggregate(const vector<Object> &vec):m_CurIdx(0)
	{
		m_ObjVec = vec;
	}
	ConCreateAggregate() :m_CurIdx(0)
	{}
	virtual Object& GetItem(const int Idx) /*const*/ //后const返回常引用
	{
		assert(Idx<Size());
		return m_ObjVec[Idx];
	}
	virtual Object& operator[](const int Idx)
	{
		return GetItem(Idx);
	}
	virtual int Size()const
	{
		return m_ObjVec.size();
	}
	virtual bool Empty()const
	{
		return 0 == Size();
	}
	virtual void Add(const Object& Obj)
	{
		m_ObjVec.push_back(Obj);
	}
	virtual void Remove()
	{
		if (!Empty())
		{
			m_ObjVec.pop_back();
		}
	}

private:
	vector<Object> m_ObjVec;
	int m_CurIdx;

};
#endif // ! _AGGREGATE_H_
</span>

<span style="font-size:18px;">#pragma once
#ifndef _ITERATOR_H_
#define _ITERATOR_H_
#include<cassert>
#include<string>
using std::string;
class Aggregate;
typedef string Object;
//抽象迭代器
class Iterator
{
public:
	Iterator()
	{}
	virtual ~Iterator()
	{}
	//这些接口 在反向迭代器中也是可以使用的比如STL中反向迭代器
	virtual void First() = 0;
	virtual void Next() = 0;
	virtual bool IsDone() = 0;
	virtual Object& GetCurItem() = 0;
protected:
	int m_Curidx;
	Aggregate* m_pAgg;
};

//具体迭代器
class ConCreIterator :public Iterator
{
public:
	ConCreIterator(Aggregate* pAgg)
	{
		m_pAgg = pAgg;
		m_Curidx = 0;
	}
	virtual void First()
	{
		m_Curidx = 0;
	}
	virtual void Next()
	{
		if (m_Curidx < m_pAgg->Size())
		{
			++m_Curidx;
		}
	}
	virtual bool IsDone()
	{
		return m_Curidx == m_pAgg->Size();
	}
	virtual Object& GetCurItem()
	{
		assert(m_Curidx<m_pAgg->Size());
		return m_pAgg->operator[](m_Curidx);
	}
};
#endif</span>

<span style="font-size:18px;">#include<iostream>
#include"Aggregate.h"
#include"Iterator.h"
using namespace std;
int main(void)
{
	//用基类指针只能调用基类函数 所以接口的设计很重要
	Aggregate* pAgg = new ConCreateAggregate();
	//这里没有使用工厂模式(在Aggregate中增加接口即可)
	Iterator* pIter = new ConCreIterator(pAgg);
	pAgg->Add("zhang");
	pAgg->Add("liu");
	pAgg->Add("zhao");
	pAgg->Add("wang");
	pAgg->Remove();
	while (!pIter->IsDone())
	{
		cout << pIter->GetCurItem()<<endl;
		pIter->Next();
	}

	delete pAgg;
	pAgg = nullptr;

	delete pIter;
	pIter = nullptr;
	return 0;
}</span>