设计模式分析——迭代器模式（Iterator）

最新推荐文章于 2024-07-27 18:05:15 发布

胖黄儿

最新推荐文章于 2024-07-27 18:05:15 发布

阅读量561

点赞数 2

文章标签：设计模式 c++

任何形式的转载，都必须联系作者获得授权，并注明出处。

本文链接：https://blog.csdn.net/hyp19991114/article/details/110356280

版权

1 迭代器模式概述

1.1 模式的提出

在程序设计中，经常要访问一个聚合对象中的各个元素，如链表、集合的遍历。通常的做法是将链表的创建和遍历都放在同一个类中。但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了面向对象设计原则中的开闭原则。

将遍历方法封装在聚合类中是不可取的，但如果让用户自己实现遍历方法也不太好。首先这增加了用户的负担；其次这会暴露聚合类的内部表示，违背了面向对象编程的封装特性。

上面的两种方法都有不妥之处，为了解决这个问题，“迭代器模式”便应运而生了。

1.2 模式的定义与归类

1.2.1 模式的定义（意图）

提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

1.2.2 模式的归类

迭代器模式属于对象行为型模式。

对象行为型模式描述了一组对等的对象之间怎样相互协作共同完成其中任何一个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

2 迭代器模式的结构与实现

2.1 模式的结构

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，这符合面向对象设计的单一职责原则。该设计模式的参与者分别是：

Iterator（抽象迭代器）
定义访问和遍历元素的接口，通常包含 first() 、next() 、isDone() 等方法。
ConcreteIterator（具体迭代器）
实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，并记录遍历的当前位置。
Aggregate（抽象聚合）
定义存储、添加、删除聚合对象以及创建相应迭代器对象的接口。
ConcreteAggregate（具体聚合）
实现创建相应迭代器的接口，返回一个具体迭代器的实例。

迭代器模式的结构如图 1 所示。
图 1 迭代器模式的结构

2.2 模式的实现

本小节以外部迭代器为例，具体阐述迭代器模式的实现方式。

2.2.1 抽象迭代器 Iterator

Iterator 类的实现如代码片段 1 所示。

【代码片段 1】抽象迭代器 Iterator 的实现

template<class Item>
class Iterator
{
public:
	Iterator() {}
	virtual ~Iterator() {}
	virtual void first() = 0;
	virtual void next() = 0;
	virtual Item *currentItem() = 0;
	virtual bool isDone() = 0;
};

2.2.2 具体迭代器 ConcreteIterator

ConcreteIterator 类的实现如代码片段 2 所示。

【代码片段 2】具体迭代器 ConcreteIterator 的实现

template<class Item>
class ConcreteIterator: public Iterator<Item>
{
private:
	Aggregate<Item> *aggregate;
	int currentIndex;

public:
	ConcreteIterator(Aggregate<Item> *aggregate): aggregate(aggregate), currentIndex(0) {}
	virtual ~ConcreteIterator() {}

	virtual void first()
	{
		currentIndex = 0;
	}
	virtual void next()
	{
		if(currentIndex < aggregate->size())
		{
			++currentIndex;
		}
	}
	virtual Item *currentItem()
	{
		if(!isDone())
		{
			return (aggregate->at(currentIndex));
		}
		else
		{
			throw "ConcreteIterator out of range!";
		}
	}
	virtual bool isDone()
	{
		return currentIndex >= aggregate->size();
	}
};

ConcreteIterator 实现了 Iterator 中定义的 4 个方法：

first() 将迭代器指向聚合中的第一个元素。
next() 使迭代器向前推进一步。
isDone() 检查指向当前元素的索引是否超出了范围。
currentItem() 返回当前索引指向的元素。如果迭代已经终止，则抛出一个异常。

2.2.3 抽象聚合 Aggregate

Aggregate 类的实现如代码片段 3 所示。

【代码片段 3】抽象聚合 Aggregate 的实现

template<class Item>
class Aggregate
{
public:
	Aggregate() {}
	virtual ~Aggregate() {}
	virtual size_t size() = 0;
	virtual void append(Item item) = 0;
	virtual Item *at(const int index) = 0;
	virtual Iterator<Item> *createIterator() = 0;
};

2.2.4 具体聚合 ConcreteAggregate

ConcreteAggregate 类的实现如代码片段 4 所示。

【代码片段 4】具体聚合 ConcreteAggregate 的实现

template <class Item>
class ConcreteAggregate: public Aggregate<Item>
{
private:
	std::vector<Item> data;

public:
	ConcreteAggregate() {}
	virtual ~ConcreteAggregate() {}

	virtual size_t size()
	{
		return data.size();
	}
	virtual void append(Item item)
	{
		data.push_back(item);
	}
	virtual Item *at(const int index)
	{
		return &data[index];
	}
	virtual Iterator<Item> *createIterator()
	{
		return new ConcreteIterator<Item>(this);
	}
};

ConcreteAggregate 实现了一个线性表，其底层基于 STL 中的 vector，包含如下方法：

size() 返回线性表中对象的数目。
append(item) 在线性表尾部添加元素 item。
at(index) 返回指定下标 index 处的对象，但并不检查指定的下标是否合法。
createIterator() 返回可以遍历本线性表的迭代器。

2.2.5 用户端

用户端的代码如代码片段 5 所示。

【代码片段 5】用户端的代码

int main(int argc, char *argv[])
{
	Aggregate<int> *list = new ConcreteAggregate<int>;
	for(int i = 1; i <= 10; i++)
	{
		list->append(i);
	}

	Iterator<int> *iter = list->createIterator();
	for(iter->first(); !iter->isDone(); iter->next())
	{
		printf("%d ", *(iter->currentItem()));
	}
	printf("\n");

	try
	{
		iter->next();
		printf("%d", *(iter->currentItem()));
	}
	catch(const char *errorMessage)
	{
		puts(errorMessage);
	}

	return 0;
}