[设计模式]行为模式-迭代器(C++描述)

second60 20180605

1. 迭代器模式定义

迭代器，作为学C++的人，应该都接触过迭代器。在STL的每个容器中，都会对应有个迭代器。

迭代器的目的很简单，就是用来遍历用的。

定义：顺序访问集合对象的元素，不需要知道集合对象的底层表示。

2. 迭代器模式结构图

分析：

1. 聚合类父类Aggregate:也可以说是容器类父类，里面存放的是某种结构的容器，可以是链表，也可以是数组等，里面包含创建迭器器的方类。

2. 实体聚合类ConcreteAggregate: 具体容器类，容器的真正实现。

3. 迭代器Iterator: 包含迭代器的常用操作,begin,end,next,++等

4. 具体迭代器类ConcreteIterator:迭代器实现类

3. 代码

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

#define MAXSIZE 1024
class ConcreteAggregate: public  Aggregate
{
public :
    ConcreteAggregate()
    {
        for(int i = 0; i < MAXSIZE; i++)
        _objs[i] = i;
    }
    ~ConcreteAggregate(){}
    Iterator * createIterator()
    {
        return new ConcreteIterator(this);
    }

    Object getItem(int idx){
        if(idx < this->getSize())
            return _objs[idx];
        else
            return -1;
    }

    int getsize(){return MAXSIZE;}
private:
    Object _objs[MAXSIZE];
};

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

class ConcreteIterator: public Iterator
{
public:
    ConcreteIterator(Aggregate* ag, int idx = 0)
    {
        _ag = ag;
        _idx = idx;
    }

    ~ConcreteIterator(){}
    void First(){_idx = 0;}
    void Next(){ if(_idx < _ag->GetSize()) _idx++;}
    bool IsDone(){return (_idx == _ag->GetSize());}
    Object  CurrentItem()
    {
        return _ag->GetItem(_idx);
    }
private:
    Aggregate* _ag;
    int _idx;
};

int main()
{
    Aggregate *ag = new ConcreteAggregate();
    Iterator *it = new ConcreteIterator(ag);
    for(; !it->IsDone()); it->Next())
    {
        cout << it->CurrentItem() << endl;
    }
    return 0;
}

4 使用场景

1. 遍历一个聚合对象

2. 无须知道聚合对象内部实现

5 优缺点

优点：

1. 它支持以不同的方式遍历一个聚合对象。（正向或逆向）

2. 迭代器简化了聚合类。

3. 在同一个聚合上可以有多个遍历。

4. 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

1. 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

6 总结

在容器中，具本都会用到迭代器，目的是为了方便容器的遍历，使容器和具体的遍历分离出来。

在写容器时，具本都会自已写个迭代器，无论是面向对象还是面向过程，迭代器都是通用的。在redis源码中，有具体的面向过程迭代器的现实，参考： https://blog.csdn.net/second60/article/details/80287897

23个设计模式，这是第22个了。坚持就是胜利。