前言

    在平常生活当中，我们经常要使用到迭代器，例如在观看一组图片时，我们经常使用遍历的方法观看，我们并不需要具体研究图片的结构，只需要遍历，并且可以将当前的遍历状态记录下来，下次观看时可以从之前的遍历终止点开始继续。

    即在面向对象的软件设计中，我们经常会遇到一类集合对象，这类集合对象的内部结构可能有着各种各样的实现，但是最重要的是有两点是需要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则，所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。

1.别人可能要用到我们的容器元素，使用迭代器可以访问各个元素而不暴露容器内部细节。

2.可以有一种以上的方式遍历容器元素

3.同时对容器元素进行多次遍历。因为迭代器会保存当前的遍历状态，所以可以通过迭代器模式来达到这种需求。

迭代器（Iterator）模式

    又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

UML图：

Iterator：定义迭代器访问和遍历元素的接口；
ConcreteIterator：实现具体的迭代器；
Aggregate：定义的容器，创建相应迭代器对象的接口；
ConcreteAggregate：具体的容器实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。

代码如下：

#include <iostream>  
#include <vector>  
using namespace std;  

template<class T>  class Iterator; 
template<class T> class ConcreteIterator;
//集合角色
template<class T> class Aggregate
{
public:  
	virtual ConcreteIterator<T> begin()=0;  
	virtual ConcreteIterator<T> end()=0;  
	virtual ~Aggregate(){}  
};
template<class T>  class ConcreteAggregate:public Aggregate<T>  
{

	vector<T >data;  
public:  
	ConcreteAggregate()  
	{  
		data.push_back(1);  
		data.push_back(2);  
		data.push_back(3);  
	}  
	virtual ConcreteIterator<T> begin()  
	{  
		return  ConcreteIterator<T>(this);  
	}  
	virtual ConcreteIterator<T> end()  
	{  
		return  ConcreteIterator<T>(this,data.size());  
	}  
	T& operator[](int index)  
	{  
		return data[index];  
	}  

};



template<class T> class Iterator  
{  
public:
	//virtual Iterator<T>&  operator ++(int);
	//virtual Iterator<T>&  operator ++();
	//
	//virtual  const T&  operator*() const;
	virtual T&  getCur()=0;

};  


template<class T> class ConcreteIterator:public Iterator<T>
{
private: 
	ConcreteAggregate<T>* m_pAG;
	int cur; 
public:
	ConcreteIterator(ConcreteAggregate<T>*a):m_pAG(a),cur(0){}  
	ConcreteIterator(ConcreteAggregate<T>*a,int len):m_pAG(a),cur(len){}  
	ConcreteIterator<T>&  operator ++(int)
	{
		ConcreteIterator<T> ret(*this);
		++*this;
		return ret;
	}
	ConcreteIterator<T>&  operator ++()
	{
		cur++;
		return *this;
	}
	ConcreteIterator<T>&  operator =(ConcreteIterator<T>& rhs)
	{
		this=rhs；
		return *this;
	}
	bool  operator !=(ConcreteIterator<T>& rhs)
	{
		return this->cur!=rhs.cur;

	}

	 T&  getCur() 
	{
		T temp=(*m_pAG)[cur];
		return temp;
	}
};


int main()  
{  
	Aggregate<int> * aggr =new ConcreteAggregate<int>();  
	ConcreteIterator<int> it=aggr->begin();  


	//it++;
	
	for(;it!=aggr->end();it++)  
	{  
		cout<<it.getCur();
	}  
//	delete it;  
	delete aggr;  
	return 0;  
}  

设计模式之: 迭代器模式