一：概念
迭代模式是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。
在应用Iterator模式之前，首先应该明白Iterator模式用来解决什么问题。或者说，如果不使用Iterator模式，会存在什么问题？
1.由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法
2.让调用者自己实现遍历。直接暴露数据细节给外部。
以上方法1与方法2都可以实现对遍历，这样有问题呢？
1，容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能。
2，往往容器在实现遍历的过程中，需要保存遍历状态，当跟元素的添加删除等功能夹杂在一起，很容易引起混乱和程序运行错误等。
Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。
所以，Iterator模式的应用场景可以归纳为满足以下几个条件：
1.访问容器中包含的内部对象；
2.按顺序访问
二：动机
在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明的访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。
使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“因对变化中的集合对象”提供了一种优雅的方式。
三：模式定义
提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露（隔离变化，稳定）该对象的内部表示。
——《设计模式》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;
}
使用模板函数实现（重点）
转载于:https://www.cnblogs.com/ssyfj/p/9546278.html
相关资源：各显卡算力对照表！
