设计模式之迭代器模式

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

背景：聚合对象拥有两个职责：一是存储数据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为。

实现原理：继承、虚函数多态重写、依赖、关联关系。

在迭代器模式结构图中包含如下几个角色：

       ● Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

       ● ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。

       ● Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。

       ● ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。
 

因为具体聚合类与具体迭代器类之间同时存在的依赖关系和关联关系。

具体聚合类 依赖 具体迭代器类，具体迭代器类 关联 具体聚合类。

所以编译时，引用的头文件讲究先后顺序，先引用具体聚合类的，再引用具体迭代器类。不然编译通不过。

优点

       (1) 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。

       (2) 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。

       (3) 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

      缺点

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

       (2) 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

       适用场景

          (1) 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。

       (2) 需要为一个聚合对象提供多种遍历方式。

       (3) 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。
 

在c++代码实现中，通过模板类的方式，可以兼容更多的数据类型。

#pragma once

//抽象迭代器
template <class T>
class Iterator
{
public:
	virtual void next() = 0; //移至下一个元素
	virtual bool isLast() = 0; //判断是否为最后一个元素
	virtual void previous() = 0;//移至上一个元素
	virtual bool isFirst() = 0;//判断是否为第一个元素
	virtual T getNextItem() = 0; //获取下一个元素
	virtual T getPreviousItem() = 0;//获取上一个元素
};

#pragma once
#include <afxtempl.h>
#include <afx.h>
#include "Iterator.h"


//抽象聚合类
template <class T>
class Aggregate
{
public:
	virtual void addObject(T obj) {}
	virtual T *getObject() { return nullptr; }

	//声明创建迭代器对象的抽象工厂方法
	virtual Iterator<T> *createIterator() { return nullptr; }
};


//商品数据类：具体聚合类
template <class T>
class ConcreteAggregate :public Aggregate<T>
{
private:
	CArray<T, T&> data;
public:
	void addObject(T obj) {
		data.Add(obj);
	}
	CArray<T, T&> *GetObj() {
		return &data;
	}

	//实现创建迭代器对象的具体工厂方法
	Iterator<T> *createIterator() {
		return new ConcreteIterator<T>(this);
	}
};

#pragma once
#include "Iterator.h"

//商品迭代器：具体迭代器
template <class T>
class ConcreteIterator :public Iterator<T>
{
public:
	ConcreteIterator(ConcreteAggregate<T> *list) {
		if (list)
		{
			m_productList = list;
			cursor1 = 0; //设置正向遍历游标的初始值
			cursor2 = m_productList->GetObj()->GetSize() - 1; //设置逆向遍历游标的初始值
		}
	}
	void next() {
		if (cursor1 < m_productList->GetObj()->GetSize()) {
			cursor1++;
		}
	}

	bool isLast() {
		return (cursor1 == m_productList->GetObj()->GetSize());
	}

	void previous() {
		if (cursor2 > -1) {
			cursor2--;
		}
	}

	bool isFirst() {
		return (cursor2 == -1);
	}

	T getNextItem() {
		return m_productList->GetObj()->GetAt(cursor1);
	}

	T getPreviousItem() {
		return m_productList->GetObj()->GetAt(cursor2);
	}
private:
	ConcreteAggregate<T> *m_productList;
	int cursor1; //定义一个游标，用于记录正向遍历的位置
	int cursor2; //定义一个游标，用于记录逆向遍历的位置
};

#include "Iterator.h"
#include "IteratorPattern.h"
#include "ConcreteIterator.h"

void TestIteratorPattern()
{
	Aggregate<string> * aggr = new ConcreteAggregate<string>();
	aggr->addObject("倚天剑");
	aggr->addObject("屠龙刀");
	aggr->addObject("四十二章经");

	Iterator<string> * it = aggr->createIterator();
	while (it->isLast() == false)
	{
		TRACE("%s\n", it->getNextItem().c_str());
		it->next();
	}
	delete it;
	delete aggr;

}

参考：设计模式-迭代器模式 C++实现_不很正派的专栏-CSDN博客_c++ 迭代器模式