C++设计模式（十六）—迭代器模式

迭代器模式

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

本文讲解迭代器模式框架，代码使用C++语言描述，代码存在的不足或问题有望各位指出。

迭代器模式框架

//迭代器模式
#include <iostream>
#include <string>
using namespace std;

typedef int Object;
class CreateIterator;
class Iterator
{
public:
    virtual ~Iterator(){}
    virtual void First()=0;
    virtual void Next()=0;
    virtual bool isDone()=0;
    virtual Object CurrentItem()=0;
protected:
    Iterator(){}

};

class Aggregate
{
public:
    virtual ~Aggregate(){}
    virtual Iterator* createIterator()=0;
    virtual Object getItem(int idx) =0;
    virtual int getSize() =0;
protected:
    Aggregate(){}
};

class ConCreteAggregate:public Aggregate
{
public:
    enum{SIZE =3};
    ConCreteAggregate()
    {
        for(int i=0; i<SIZE;i++)
        {
            _obj[i]=i;
        }
    }
    ~ConCreteAggregate(){}
    Iterator* createIterator() override;
    Object getItem(int idx) override
    {
        if(idx < getSize())
            return _obj[idx];
        else
            return -1;
    }
    int getSize() override
    {
        return SIZE;
    }

private:
    Object _obj[SIZE];

};


class ConcreateIterator:public Iterator
{
public:
    ConcreateIterator(Aggregate* ag,int idx=0)
    {
        _ag = ag;
        _idx =idx;
    }
    ~ConcreateIterator(){}
    void First() override
    {
        _idx =0;
    }
    void Next() override
    {
        if(_idx <_ag->getSize())
            _idx++;
    }
    bool isDone() override
    {
        return (_idx == _ag->getSize());
    }
    Object CurrentItem() override
    {
        return _ag->getItem(_idx);
    }
private:
    Aggregate *_ag;
    int _idx;
};


Iterator* ConCreteAggregate::createIterator()
{
    return new ConcreateIterator(this);

}

int main()
{

    Aggregate *ag = new ConCreteAggregate();
    Iterator *it = new ConcreateIterator(ag);
    for(;!it->isDone();it->Next())
    {
        cout << it->CurrentItem()<< endl;
    }
    delete ag;
    delete it;
    return 0;
}

迭代器模式优点

迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合内部结构，又可以让外部代码透明地访问集合内部的数据。