定义

迭代器模式（Iterator Pattern）是一种行为设计模式，它提供一种方法顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示。迭代器模式将遍历过程从聚合对象中分离出来，使得相同的遍历操作可以应用于不同的聚合结构之上。

结构

Iterator（迭代器接口） ：定义访问和遍历元素的接口，一般包含 next()、hasNext() 等方法。
ConcreteIterator（具体迭代器） ：实现迭代器接口，完成集合元素的遍历。
Aggregate（聚合接口） ：定义创建迭代器的接口。
ConcreteAggregate（具体聚合类） ：实现聚合接口，创建具体迭代器实例。

优点

简化聚合类：迭代器模式将集合遍历行为抽离出来，简化了聚合类的实现。
统一遍历接口：客户端可以通过相同的接口遍历不同类型的聚合对象，而不需要了解它们的内部实现。
支持多种遍历方式：可以在不修改集合类的前提下，定义不同的迭代器来实现不同的遍历策略。

代码示例

#include <iostream>
#include <vector>

// 迭代器接口
template <typename T>
class Iterator
{
public:
	virtual ~Iterator() = default;
	virtual bool hasNext() const = 0;
	virtual T next() = 0;
};


// 聚合接口
template <typename T>
class Aggregate
{
public:
	virtual ~Aggregate() {}
	virtual Iterator<T>* createIterator() const = 0;
};


// 前向声明
template <typename T>
class ConcreteAggregate;


// 具体迭代器
template <typename T>
class ConcreteIterator : public Iterator<T>
{
private:
	const ConcreteAggregate<T>* aggregate;
	int index;

public:
	ConcreteIterator(const ConcreteAggregate<T>* agg) : aggregate(agg), index(0) {}

	bool hasNext() const override
	{
		return index < aggregate->size();
	}

	T next() override
	{
		return aggregate->get(index++);
	}
};



// 具体聚合类
template <typename T>
class ConcreteAggregate : public Aggregate<T>
{
private:
	std::vector<T> items;

public:
	ConcreteAggregate(std::initializer_list<T> list) : items(list) {}

	Iterator<T>* createIterator() const override
	{
		return new ConcreteIterator<T>(this);
	}

	int size() const
	{
		return items.size();
	}

	T get(int index) const
	{
		return items[index];
	}
};




int main()
{
	ConcreteAggregate<int> numbers = { 7, 2, 1, 4, 3 };
	std::unique_ptr<Iterator<int>> it(numbers.createIterator());

	while (it->hasNext())
	{
		std::cout << it->next() << " ";
	}
	std::cout << std::endl;

	system("pause");
	return 0;
}

设计模式---迭代器模式

定义

结构

优点

代码示例