迭代器模式
2020 年 09 月 17 日 237 330 字 暂无评论

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

版权属于:zfh

本文链接:http://zfhblog.com/index.php/archives/153/



评论已关闭