C++实现迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示（将对聚合对象的遍历封装到一个类中进行）。属于行为型模式

优点： 1、它支持以不同的方式遍历一个聚合对象（容器）。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

Iterator（迭代器）【迭代器类定义访问和遍历元素的接口】

ConcreteIterator （具体迭代器）【具体迭代器类实现迭代器接口，对聚合对象进行访问和遍历】

Aggregate （聚合）【聚合类定义创建相应迭代器对象的接口】

ConcreteAggregate （具体聚合）【具体聚合类实现了创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例】

class Iterator; 
typedef int Object; 
class Interator; 
class Aggregate //抽象类-聚合对象类
{ 
public: 
 virtual ~Aggregate(); 
 virtual Iterator* CreateIterator() = 0; 
 virtual Object GetItem(int idx) = 0; 
 virtual int GetSize() = 0;
protected: 
 Aggregate(); 
}; 
class ConcreteAggregate:public Aggregate //子类-具体的聚合对象类
{ 
public: 
 enum {SIZE = 3}; 
 ConcreteAggregate();
 ~ConcreteAggregate(); 
 Iterator* CreateIterator(); 
Object GetItem(int idx); 
 int GetSize(); 
protected: 
 Object _objs[SIZE];
}; 

#include "Aggregate.h" 
#include "Iterator.h"
#include <iostream>
using namespace std; 
Aggregate::Aggregate() 
{ 
} 
Aggregate::~Aggregate() 
{ 
} 
ConcreteAggregate::ConcreteAggregate() 
{ 
 for (int i = 0; i < SIZE; i++) 
 _objs[i] = i; 
} 
ConcreteAggregate::~ConcreteAggregate() 
{ 
} 
Iterator* ConcreteAggregate::CreateIterator() 
{ 
 return new ConcreteIterator(this); 
} 
Object ConcreteAggregate::GetItem(int idx) 
{ 
 if (idx < this->GetSize()) 
 return _objs[idx]; 
 else 
  return -1; 
} 
int ConcreteAggregate::GetSize() 
{ 
 return SIZE; 
} 

class Aggregate; 
typedef int Object; 
class Iterator //抽象类-迭代器类
{ 
public: 
 virtual ~Iterator();
 virtual void First() = 0; 
 virtual void Next() = 0; 
 virtual bool IsDone() = 0; 
 virtual Object CurrentItem() = 0; 
protected: 
 Iterator(); 
}; 
class ConcreteIterator:public Iterator//子类-具体的迭代器类
{ 
public: 
 ConcreteIterator(Aggregate* ag , int idx = 0); 
 ~ConcreteIterator(); 
 void First(); 
  void Next(); 
 bool IsDone(); 
 Object CurrentItem(); 
protected: 
private: 
 Aggregate* _ag; 
 int _idx; 
}; 

#include "Iterator.h"
#include "Aggregate.h" 
#include <iostream>
using namespace std; 
Iterator::Iterator() 
{ 
} 
Iterator::~Iterator() 
{ 
} 
ConcreteIterator::ConcreteIterator(Aggregate* ag , int idx) 
{ 
 this->_ag = ag; 
 this->_idx = idx; 
} 
ConcreteIterator::~ConcreteIterator() 
{ 
} 
Object ConcreteIterator::CurrentItem()
{ 
 return _ag->GetItem(_idx); 
} 
void ConcreteIterator::First() 
{ 
 _idx = 0;
} 
void ConcreteIterator::Next() 
{ 
 if (_idx < _ag->GetSize()) 
 _idx++;
} 

bool ConcreteIterator::IsDone() 
{ 
 return (_idx == _ag->GetSize()); 
} 

#include "Iterator.h"
#include "Aggregate.h" 
#include <iostream>
using namespace std; 
int main(int argc,char* argv[]) 
{ 
 Aggregate* ag = new ConcreteAggregate(); //聚合对象
  Iterator* it = new ConcreteIterator(ag); //迭代器对象
//Iterator* it = ag->CreateIterator();
 for (; !(it->IsDone()) ; it->Next()) //使用迭代器对象遍历聚合对象各元素
 { 
 cout<<it->CurrentItem()<<endl; 
 } 
 return 0;
} 

这里提到了迭代器的概念和实现。具体关于迭代器的用法和特性，可以到我之前博文STL之迭代器查看，或者是到侯捷的《STL源码剖析》第三章节阅读。。