01.概念

• Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。所以，Iterator模式的应用场景可以归纳为满足以下几个条件：

  • 访问容器中包含的内部对象
  • 按顺序访问

02.角色和职责

• 提供一种方法顺序访问一个聚敛对象的各个元素，而又不暴露该对象的内部表示。
• 为遍历不同的聚集结构提供如开始，下一个，是否结束，当前一项等统一接口。

• Iterator（迭代器接口）：

  • 该接口必须定义实现迭代功能的最小定义方法集
  • 比如提供hasNext()和next()方法。

• ConcreteIterator（迭代器实现类）：

  • 迭代器接口Iterator的实现类。可以根据具体情况加以实现。

• Aggregate（容器接口）：

  • 定义基本功能以及提供类似Iterator iterator()的方法。

• ConcreteAggregate（容器实现类）：

  • 容器接口的实现类。必须实现Iterator iterator()方法。

03.代码案例

#include <iostream>

using namespace std;

typedef int Object;
#define SIZE 5

class MyIterator
{
public:
        virtual void First() = 0;
        virtual void Next() = 0;
        virtual bool IsDone() = 0;
        virtual Object CurrentItem() = 0;
private:
};

class Aggregate
{
public:
        virtual Object getItem(int index) = 0;
        virtual MyIterator* CreateIterator() = 0;
        virtual int getSize() = 0;
private:
};

class Contretelterator : public MyIterator
{
public:
        Contretelterator(Aggregate* ag)
        {
                _ag = ag;
                _idx = 0;
        }
        ~Contretelterator()
        {
                _ag = NULL;
                _idx = 0;
        }
        virtual void First()
        {
                _idx = 0;
        }
        virtual void Next()
        {
                if (_idx < _ag->getSize())
                {
                        _idx++;
                }
        }
        virtual bool IsDone()
        {
                return (_idx == _ag->getSize());
        }
        virtual Object CurrentItem()
        {
                return _ag->getItem(_idx);
        }
private:
        int _idx;
        Aggregate* _ag;
};

class ConcreteAggregate : public Aggregate
{
public:
        ConcreteAggregate()
        {
                for (int i = 0; i < SIZE; i++)
                {
                        object[i] = i + 1;
                }    
        }
        ~ConcreteAggregate()
        {

        }
        virtual Object getItem(int index)
        {
                return object[index];
        }
        virtual MyIterator* CreateIterator()
        {
                return new Contretelterator(this);
        }
        virtual int getSize()
        {
                return SIZE;
        }
private:
        Object object[SIZE];
};

void main()
{
        //创建一个集合
        Aggregate* ag = new ConcreteAggregate();
        //创建一个遍历这个集合的 迭代器
        MyIterator* it = ag->CreateIterator();
        //通过迭代器遍历集合
        for (it->First(); !(it->IsDone()); it->Next())
        {
                cout << it->CurrentItem() << " ";
        }
        delete it;
        delete ag;
}

• 输出

1 2 3 4 5