设计模式: 迭代模式

前言

    在寻常生活其中，我们常常要使用到迭代器。比如在观看一组图片时，我们常常使用遍历的方法观看，我们并不须要详细研究图片的结构，仅仅须要遍历，而且能够将当前的遍历状态记录下来，下次观看时能够从之前的遍历终止点開始继续。

    即在面向对象的软件设计中，我们常常会遇到一类集合对象。这类集合对象的内部结构可能有着各种各样的实现。可是最重要的是有两点是须要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则。所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。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;  
}  

感觉自己写的有点问题。主要想重载操作符++跟*之类的。老是不成功，想做成跟c++里面的迭代器一样，可是详细里面里面怎么实现还不清楚。要是谁有资料能把链接发给我看看就谢谢啦~