设计模式之迭代器模式-来看看怎么迭代的

迭代器模式

• 一、迭代器模式的概念
• 二、迭代器模式使用场景
• 三、迭代器模式构建方法
• 1、迭代器抽象类（Iterator）
• 2、迭代器具体实现类（ConcreteIterator）
• 3、容器抽象类（Aggregate）
• 4、容器具体实现类（concreteAggregate）
• 四、迭代器模式的示例
• 五、迭代器模式的优缺点
• 优点：
• 缺点：

一、迭代器模式的概念

迭代器模式属于行为型模式，用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

二、迭代器模式使用场景

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

三、迭代器模式构建方法

1、迭代器抽象类（Iterator）

迭代器抽象类定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，是迭代器具体实现类的父类。

2、迭代器具体实现类（ConcreteIterator）

迭代器具体实现类用于实现迭代器抽象类中定义的接口和方法。

3、容器抽象类（Aggregate）

容器抽象类用于存储和管理元素对象，声明一个用于创建一个迭代器对象的方法，充当抽象迭代器工厂角色。

4、容器具体实现类（concreteAggregate）

容器具体实现类用于实现容器抽象类中定义的接口和方法

四、迭代器模式的示例

// IteratorPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <vector>

#define DELETE_PTR(p) {if(p!=nullptr){delete (p); (p)=nullptr;}}

using namespace std;

class MyIterator
{
public:
	virtual void first() = 0;
	virtual void next() = 0;
	virtual int currentItem() = 0;
	virtual bool isEnd() = 0;
};

class Aggregate
{
public:
	virtual void addItem(int num) = 0;
	virtual int getItem(int index) = 0;
	virtual MyIterator *createIterator() = 0;
	virtual int getSize() = 0;
};

class ConcreteIterator : public MyIterator
{
public:
	ConcreteIterator(Aggregate *pAggregate)
	{
		m_pAggregate = pAggregate;
		m_index = 0;
	}

	~ConcreteIterator()
	{
		DELETE_PTR(m_pAggregate);
		m_index = 0;
	}

	void first()
	{
		m_index = 0;
	}

	void next()
	{
		if (m_index < m_pAggregate->getSize())
		{
			m_index++;
		}
	}

	int currentItem()
	{
		return m_pAggregate->getItem(m_index);
	}

	bool isEnd()
	{
		if (m_index == m_pAggregate->getSize())
		{
			return true;
		}
		return false;
	}

private:
	int m_index;
	Aggregate *m_pAggregate;
};

class ConcreteAggregate : public Aggregate
{
public:
	ConcreteAggregate()
	{
		m_elemVec.clear();
	}

	~ConcreteAggregate()
	{
		if (!m_elemVec.empty())
		{
			vector<int> tmpVec;
			m_elemVec.swap(tmpVec);// 释放内存
			m_elemVec.clear();
		}
	}

	void addItem(int num)
	{
		cout << "迭代器中添加元素： " << num << endl;
		m_elemVec.push_back(num);
	}

	int getItem(int index)
	{
		if (index < m_elemVec.size())
		{
			return m_elemVec.at(index);
		}
		return -1;
	}

	{
		return new ConcreteIterator(this);
	}

	int getSize()
	{
		return m_elemVec.size();
	}


private:
	vector<int> m_elemVec;;
};



int main()
{
	cout << "--------------------迭代器模式--------------------" << endl;
	Aggregate *pAggregate = dynamic_cast<Aggregate*>(new ConcreteAggregate);
	pAggregate->addItem(1);
	pAggregate->addItem(2);
	pAggregate->addItem(3);
	pAggregate->addItem(4);
	pAggregate->addItem(5);
	pAggregate->addItem(6);
	pAggregate->addItem(7);
	pAggregate->addItem(8);
	pAggregate->addItem(9);
	pAggregate->addItem(10);

	MyIterator *myIter = pAggregate->createIterator();
	
	cout << "----------------打印出所有的元素------------------" << endl;
	while (!myIter->isEnd())
	{
		cout << myIter->currentItem() << "  ";
		myIter->next();
	}
	cout << endl;

	DELETE_PTR(pAggregate);
	DELETE_PTR(myIter);

    std::cout << "Hello World!\n";
	getchar();
}

运行结果：

五、迭代器模式的优缺点

优点：

1、它支持以不同的方式遍历一个聚合对象，在同一个聚合上可以有多个遍历。
2、迭代器简化了聚合类，迭代器的引入，不需要在原有聚合对象中提供遍历数据的方法。
3、增加新的聚合类和迭代器类都很方便，无须修改原有代码，符合“开闭原则”。

缺点：

1、增加了系统的复杂性，迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数会成对增加。
2、抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展性。

能力有限，如有错误，多多指教。。。