一：概念
迭代模式是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。
在应用Iterator模式之前，首先应该明白Iterator模式用来解决什么问题。或者说，如果不使用Iterator模式，会存在什么问题？
1.由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法
2.让调用者自己实现遍历。直接暴露数据细节给外部。
以上方法1与方法2都可以实现对遍历，这样有问题呢？
1，容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能。
2，往往容器在实现遍历的过程中，需要保存遍历状态，当跟元素的添加删除等功能夹杂在一起，很容易引起混乱和程序运行错误等。
Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。
所以，Iterator模式的应用场景可以归纳为满足以下几个条件：
二：动机
在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明的访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。
使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“因对变化中的集合对象”提供了一种优雅的方式。
三：模式定义
提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露（隔离变化，稳定）该对象的内部表示。
——《设计模式》GoF
这种方式在C++现在来说已经过时了，因为泛型编程和STL中实现了迭代器。
迭代器模式最核心缺点就是出现在面向对象上，虚函数调用是有性能成本的，需要绕一个虚函数的表指针，然后找到函数地址，才能去调用，要经过指针间接运算。当循环次数太高后，性能就会被削减。
泛型编程中优点：迭代器是使用模板来实现的，而模板（也是一种多态技术），但是他实现的多态是编译时多态，编译器会在编译时判断具体是调用哪段代码。
虚函数是运行时多态，运行时多态性能低于编译时多态，编译时多态不需要计算他的地址了，因此STL性能高于面向对象模式迭代器，功能也更多。
四：类图（结构）
五：代码讲解
（一）Iterator基类
template<typename T>
class Iterator
{
public:
virtual void first() = 0;
virtual void next() = 0;
virtual bool isDone() const = 0;
virtual T& current() = 0;
};
（二）基类Collection返回迭代器
template<typename T>
class MyCollection{
public:
Iterator<T> GetIterator(){
//...
}
};
（三）子类CollectionIterator实现迭代方法
template<typename T>
class CollectionIterator : public Iterator<T>{
MyCollection<T> mc;
public:
CollectionIterator(const MyCollection<T> & c): mc(c){ }
void first() override {
}
void next() override {
}
bool isDone() const override{
}
T& current() override{
}
};
（四）进行调用
void MyAlgorithm()
{
MyCollection<int> mc;
Iterator<int> iter= mc.GetIterator();
for (iter.first(); !iter.isDone(); iter.next()){
cout << iter.current() << endl;
}
}
六：要点总结
（一）Java，C#类库是按照上面实现，因为毕竟没有编译时多态，现在C++基本没有这种实现，随着技术的发展，有些设计模式会过时，但是思想不会过时。
（二）迭代抽象：访问一个聚合对象的内容而无需暴露他的内部表示
（三）迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。
（四）迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。
七：案例实现
（一）实现迭代器基类
class Iterator
{
public:
virtual void first() = 0;
virtual void next() = 0;
virtual bool isDone() const= 0;
virtual int& current() = 0;
virtual ~Iterator(){}
};
（二）实现聚合基类
class Aggregate
{
public:
virtual Iterator* CreateIntertor() = 0;
virtual int getSize() = 0;
virtual int getItem(int index) = 0;
virtual ~Aggregate(){}
};
（三）实现具体迭代器子类
class ConcreteIterator :public Iterator
{
private:
Aggregate* _ag;
int _idx;
public:
ConcreteIterator(Aggregate* ag)
{
_ag = ag;
_idx = 0;
}
virtual void first()
{
_idx = 0;
}
virtual void next()
{
if (_idx<_ag->getSize())
_idx++;
}
virtual bool isDone() const
{
return _idx == _ag->getSize();
}
virtual int current()
{
return _ag->getItem(_idx);
}
};
（四）实现聚合子类
class ConcreteAggregate :public Aggregate
{
private:
int *Object;
int size;
public:
ConcreteAggregate(int size)
{
Object = (int *)malloc(size*sizeof(int));
for (int i = 0; i < size; i++)
Object[i] = i*i;
this->size = size;
}
virtual Iterator* CreateIntertor()
{
return new ConcreteIterator(this);
}
virtual int getSize()
{
return this->size;
}
virtual int getItem(int index)
{
return this->Object[index];
}
~ConcreteAggregate()
{
delete Object;
}
};
（五）结果测试
int main()
{
Aggregate* ag = new ConcreteAggregate(10);
Iterator* it = ag->CreateIntertor();
for (it; !it->isDone(); it->next())
cout << it->current() << endl;
delete it;
delete ag;
system("pause");
return 0;
}
#include <iostream>
#include <string>
using namespace std;
template<typename T>
class Iterator
{
public:
virtual void first() = 0;
virtual void next() = 0;
virtual bool isDone() const= 0;
virtual T& current() = 0;
virtual ~Iterator(){}
};
template<typename T>
class Aggregate
{
public:
virtual Iterator<T>* CreateIntertor() = 0;
virtual int getSize() = 0;
virtual T& getItem(int index) = 0;
virtual ~Aggregate(){}
};
template<typename T>
class ConcreteIterator :public Iterator<T>
{
private:
Aggregate<T>* _ag;
int _idx;
public:
ConcreteIterator(Aggregate<T>* ag)
{
_ag = ag;
_idx = 0;
}
virtual void first()
{
_idx = 0;
}
virtual void next()
{
if (_idx<_ag->getSize())
_idx++;
}
virtual bool isDone() const
{
return _idx == _ag->getSize();
}
virtual T& current()
{
return _ag->getItem(_idx);
}
};
template<typename T>
class ConcreteAggregate :public Aggregate<T>
{
private:
T *Object;
int size;
public:
ConcreteAggregate(int size)
{
Object = (T *)malloc(size*sizeof(T));
for (int i = 0; i < size; i++)
Object[i] = 65+i;
this->size = size;
}
virtual Iterator<T>* CreateIntertor()
{
return new ConcreteIterator<T>(this);
}
virtual int getSize()
{
return this->size;
}
virtual T& getItem(int index)
{
return this->Object[index];
}
~ConcreteAggregate()
{
delete Object;
}
};
int main()
{
Aggregate<char>* ag = new ConcreteAggregate<char>(10);
Iterator<char>* it = ag->CreateIntertor();
for (it; !it->isDone(); it->next())
cout << it->current() << endl;
delete it;
delete ag;
system("pause");
return 0;
}
使用模板函数实现（重点）
