设计模式（十七）——迭代器模式

设计模式（十七）——迭代器模式

1、迭代器模式简介

1、迭代器模式简介

迭代器模式（Iterator）提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露对象的内部表示。

    迭代器模式的本质是将遍历聚合对象中数据的行为提取出来，封装到一个迭代器中，经过专门的迭代器来遍历聚合对象的内部数据。迭代器模式符合职责单一原则。

2、迭代器模式角色

    抽象迭代器(Iterator): 迭代器定义访问和遍历元素的接口。
    具体迭代器(ConcreteIterator):  具体迭代器实现迭代器Iterator接口。对该聚合遍历时跟踪当前位置。
    抽象聚合类(Aggregate): 聚合定义建立相应迭代器对象的接口

    具体聚合类(ConcreteAggregate): 体聚合实现建立相应迭代器的接口，该操做返回ConcreteIterator的一个适当的实例。

    聚合容器是一个管理和组织数据对象的数据结构。聚合容器对象主要拥有两个职责：一是存储内部数据；二是遍历内部数据。存储数据是聚合对象最基本的职责。

    迭代器的做用：

    A、支持以不一样的方式遍历一个聚合。

    B、迭代器简化了聚合的接口

    C、在同一个聚合上能够有多个遍历。

3、迭代器模式优缺点

    迭代器模式的优势：

    A、分离了集合对象的遍历行为，简化了遍历方式

    B、能够提供多种遍历方式遍历聚合容器对象，好比正序遍历、倒序遍历

    C、封装性良好，用户只须要获得迭代器就能够遍历，既能够不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。

    D、在迭代器模式中，增长新的聚合类和迭代器类都很方便，无须修改原有代码，知足“开闭原则”的要求。

    迭代器模式的缺点：

    A、对于比较简单的遍历（如数组或者有序列表），使用迭代器方式遍历较为繁琐

    B、因为迭代器模式将存储数据和遍历数据的职责分离，增长新的聚合类须要对应增长新的迭代器类，类的个数成对增长，必定程度上增长了系统的复杂性。

四、迭代器模式使用场景

迭代器模式使用场景：

A、当须要访问一个聚合对象，并且无论对象是什么都须要遍历的时候，应该考虑用迭代器模式。

B、须要对聚有合多种遍历时，能够考虑用迭代器模式。

C、为遍历不一样的汇集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

2、迭代器模式实现

Aggregate聚合容器抽象类：

#ifndef AGGREGATE_H
#define AGGREGATE_H
#include <string>
#include <iostream>
#include <vector>
class Iterator;
using namespace std;
 
//聚合容器抽象类
class Aggregate
{
public:
    //建立迭代器接口
    virtual Iterator* createIterator() = 0;
    //获取聚合容器接口
    virtual vector<string>* getVector() = 0;
protected:
    Aggregate(){}
};
 
#endif // AGGREGATE_H

ConcreteAggregate具体实现类：

#ifndef CONCRETEAGGREGATE_H
#define CONCRETEAGGREGATE_H
#include "Aggregate.h"
#include "ConcreteIterator.h"
 
//聚合容器具体实现类
class ConcreteAggregate : public Aggregate
{
public:
    ConcreteAggregate()
    {
        m_iterms = new vector<string>;
    }
    ~ConcreteAggregate()
    {
        delete m_iterms;
        m_iterms = NULL;
    }
    Iterator* createIterator()
    {
        return new ConcreteIterator((Aggregate*)this);
    }
    vector<string>* getVector()
    {
        return m_iterms;
    }
    int count()
    {
        return m_iterms->size();
    }
    void setElement(int index, string object)
    {
        m_iterms->at(index) = object;
    }
    string getElement(int index)
    {
        return m_iterms->at(index);
    }
 
private:
    vector<string>* m_iterms;//聚合容器
};
 
#endif // CONCRETEAGGREGATE_H

Iterator迭代器抽象类：

#ifndef ITERATOR_H
#define ITERATOR_H
#include <string>
using namespace std;
 
//迭代器抽象类
class Iterator
{
public:
    //聚合容器的第一个元素接口
    virtual string first() = 0;
    //
    virtual string next() = 0;
    //
    virtual bool isDone() = 0;
    //
    virtual string currentItem() = 0;
protected:
    Iterator(){}
};

#endif // ITERATOR_H

ConcreteIterator迭代器具体实现类：

#ifndef CONCRETEITERATOR_H
#define CONCRETEITERATOR_H
#include "Iterator.h"
#include "Aggregate.h"
 
//迭代器具体实现类
class ConcreteIterator : public Iterator
{
public:
    ConcreteIterator(Aggregate* aggregate)
    {
        m_aggregate = aggregate;
        m_current = 0;
    }
    string first()
    {
        return m_aggregate->getVector()->at(0);
    }
    string next()
    {
        m_current++;
        if(m_current < m_aggregate->getVector()->size())
        {
            return m_aggregate->getVector()->at(m_current);
        }
    }
    bool isDone()
    {
        return m_current >= m_aggregate->getVector()->size() ? true : false;
    }
    string currentItem()
    {
        return m_aggregate->getVector()->at(m_current);
    }
private:
    Aggregate* m_aggregate;//迭代器操做的聚合容器
    int m_current;
};
 
#endif // CONCRETEITERATOR_H

 

客户调用程序：

#include "Iterator.h"
#include "Aggregate.h"
#include "ConcreteAggregate.h"
 
int main()
{
 
    Aggregate* aggregate = new ConcreteAggregate();
    aggregate->getVector()->push_back("apple");
    aggregate->getVector()->push_back("banana");
    aggregate->getVector()->push_back("beer");
    //建立聚合容器的迭代器
    Iterator* iter = aggregate->createIterator();
    //遍历聚合容器
    while(!iter->isDone())
    {
        cout << iter->currentItem() << " take ticket" << endl;
        iter->next();
    }
 
    delete aggregate;
    delete iter;
    return 0;
}