迭代器模式

1 核心思想

迭代器模式提供了一种方法顺序访问一个聚合对象中的各种元素，而又不暴露其内部表示。

什么时候用迭代器模式？

当需要访问一个聚集对象，而且不管这个对象是什么的时候都需要遍历(比如对象是数组、链表、map或list)，就应该考虑使用迭代器模式；当然这里说的是需要访问同时两类不同的聚集。

当需要对聚集使用不同的遍历方式时，应该考虑使用迭代器模式。

总之，需要对不同的聚集同时进行遍历或者对同一类聚集同时采用不同的遍历方式，应该考虑使用迭代器模式。

迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

2 代码实现

#include <iostream>
#include <vector>

class Iterator
{
public:
	virtual bool HasNext() = 0;
	virtual int Next() = 0;
};

class Aggregate
{
public:
	virtual Iterator* CreateIterator() = 0;
	virtual void Add(int item) = 0;
};

class ArrayIterator :public Iterator
{
public:
	ArrayIterator(int* pArray):m_position(0)
	{
		m_pArrayAgg = pArray;
	}

	bool HasNext()
	{
		if (m_position < 10)
			return true;
		else
			return false;
	}

	int Next()
	{
		int val = m_pArrayAgg[m_position];
		m_position++;
		return val;
	}
private:
	int* m_pArrayAgg;
	int m_position;
};

class ArrayAggregate :public Aggregate
{
public:
	ArrayAggregate() :m_index(0)
	{}

	Iterator* CreateIterator()
	{
		return new ArrayIterator(m_Array);
	}

	void Add(int item)
	{
		if (m_index < 10)
		{
			m_Array[m_index++] = item;
		}
		else
		{
			std::cout << "数组已满，无法再继续插入" << std::endl;
		}

	}

private:
	int m_index;
	int m_Array[10];
	
};

class VectorIterator :public Iterator
{
public:
	VectorIterator(std::vector<int>& vec):m_position(0)
	{
		m_vec = vec;
	}

	bool HasNext()
	{
		if (m_position < (int)(m_vec.size()))
			return true;
		else
			return false;
	}

	int Next()
	{
		int val = m_vec[m_position];
		m_position++;
		return val;
	}

private:
	std::vector<int> m_vec;
	int m_position;
};

class VectorAggregate :public Aggregate
{
public:
	Iterator* CreateIterator()
	{
		return new VectorIterator(m_vec);
	}

	void Add(int item)
	{
		m_vec.push_back(item);
	}

private:
	std::vector<int> m_vec;
};

class Client
{
private:
	Aggregate *m_pArray, *m_pVec;

	void PrintValue(Iterator* iter)
	{
		while (iter->HasNext())
			std::cout << iter->Next() << std::endl;
	}

public:
	Client(Aggregate *pArray, Aggregate *pVec)
	{
		m_pArray = pArray;
		m_pVec = pVec;
	}

	void Print()
	{
		std::cout << "打印数组的值:" << std::endl;
		Iterator* pArrayIter = m_pArray->CreateIterator();
		PrintValue(pArrayIter);

		std::cout << "打印vector的值:" << std::endl;
		Iterator* pVecIter = m_pVec->CreateIterator();
		PrintValue(pVecIter);
	}


};

int main()
{
	ArrayAggregate* pArray = new ArrayAggregate;
	pArray->Add(0);
	pArray->Add(2);
	pArray->Add(4);
	pArray->Add(8);

	VectorAggregate* pVec = new VectorAggregate;
	pVec->Add(1);
	pVec->Add(3);
	pVec->Add(5);
	pVec->Add(7);

	Client* pClient = new Client(pArray,pVec);
	pClient->Print();
    
	return 0;
}