迭代模式是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。

.由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法

.让调用者自己实现遍历。直接暴露数据细节给外部。 

，容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能。

，往往容器在实现遍历的过程中，需要保存遍历状态，当跟元素的添加删除等功能夹杂在一起，很容易引起混乱和程序运行错误等。

Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。

.访问容器中包含的内部对象；

.按顺序访问

在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明的访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。

使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“因对变化中的集合对象”提供了一种优雅的方式。

提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露（隔离变化，稳定）该对象的内部表示。

                                                                                    ——《设计模式》GoF

这种方式在C++现在来说已经过时了，因为泛型编程和STL中实现了迭代器。
迭代器模式最核心缺点就是出现在面向对象上，虚函数调用是有性能成本的，需要绕一个虚函数的表指针，然后找到函数地址，才能去调用，要经过指针间接运算。当循环次数太高后，性能就会被削减。
泛型编程中优点：迭代器是使用模板来实现的，而模板（也是一种多态技术），但是他实现的多态是编译时多态，编译器会在编译时判断具体是调用哪段代码。
虚函数是运行时多态，运行时多态性能低于编译时多态，编译时多态不需要计算他的地址了，因此STL性能高于面向对象模式迭代器，功能也更多。

template<typename T>

class Iterator

{

public:

    virtual void first() = ;

    virtual void next() = ;

    virtual bool isDone() const = ;

    virtual T& current() = ;

};

template<typename T>

class MyCollection{

public:

    Iterator<T> GetIterator(){

        //...

    }

};

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;

    }

}

class Iterator

{

public:

    virtual void first() = ;

    virtual void next() = ;

    virtual bool isDone() const= ;

    virtual int& current() = ;

    virtual ~Iterator(){}

};

class Aggregate

{

public:

    virtual Iterator* CreateIntertor() = ;

    virtual int getSize() = ;

    virtual int getItem(int index) = ;

    virtual ~Aggregate(){}

};

class ConcreteIterator :public Iterator

{

private:

    Aggregate* _ag;

    int _idx;

public:

    ConcreteIterator(Aggregate* ag)

    {

        _ag = ag;

        _idx = ;

    }

    virtual void first()

    {

        _idx = ;

    }

    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 = ; 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();

    Iterator* it = ag->CreateIntertor();

    for (it; !it->isDone(); it->next())

        cout << it->current() << endl;

    delete it;

    delete ag;

    system("pause");

    return ;

}

作为迭代器，最好设置为模板类吧

#include <iostream>

#include <string>

using namespace std;

template<typename T>

class Iterator

{

public:

    virtual void first() = ;

    virtual void next() = ;

    virtual bool isDone() const= ;

    virtual T& current() = ;

    virtual ~Iterator(){}

};

template<typename T>

class Aggregate

{

public:

    virtual Iterator<T>* CreateIntertor() = ;

    virtual int getSize() = ;

    virtual T& getItem(int index) = ;

    virtual ~Aggregate(){}

};

template<typename T>

class ConcreteIterator :public Iterator<T>

{

private:

    Aggregate<T>* _ag;

    int _idx;

public:

    ConcreteIterator(Aggregate<T>* ag)

    {

        _ag = ag;

        _idx = ;

    }

    virtual void first()

    {

        _idx = ;

    }

    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 = ; i < size; i++)

            Object[i] = +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>();

    Iterator<char>* it = ag->CreateIntertor();

    for (it; !it->isDone(); it->next())

        cout << it->current() << endl;

    delete it;

    delete ag;

    system("pause");

    return ;

}

使用模板函数实现（重点）