設計模式（十七）——迭代器模式

設計模式（十七）——迭代器模式

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;
}