【設計模式】——迭代器模式

迭代器模式(Iterator)，提供一種方法順序訪問一個聚合對象中各個元素，而又不暴露該對象的內部表示。當你須要訪問一個彙集對象，並且無論這些對象是什麼都須要遍歷的時候，或者你須要對彙集有多種方式遍歷時，你就應該考慮用迭代器模式，爲遍歷不一樣的彙集結構提供如開始、下一個、是否結束、當前哪一項等統一接口。

#include <iostream>
#include <vector>
using namespace std;
typedef string object;

//Iterator迭代器抽象類
class Iterator
{
    //用於定義獲得開始對象、獲得下一個對象、判斷是否到結尾、當前對象等抽象方法
public:
    virtual object First()=0;
    virtual object Next()=0;
    virtual bool IsDone()=0;
    virtual object CurrentItem()=0;
};
//Aggregate彙集抽象類
class Aggregate
{
public:
    virtual int Count() = 0;
    virtual void Push(const object& strValue)=0;
    virtual object Pop(const int nIndex)=0;
    virtual Iterator *CreateIterator()=0;
};
//ConcreteIterator具體迭代器類，繼承Iterator
class ConcreteIterator:public Iterator
{
private:
    //定義一個具體彙集對象
    Aggregate *m_aggregate;
    int m_current=0;
public:
    ConcreteIterator(Aggregate *aggregate)
    {
        this->m_aggregate=aggregate;
    }
    object First()
    {
        return m_aggregate->Pop(0);
    }
    object Next()
    {
        object strRet;
        m_current++;
        if(m_current<m_aggregate->Count())
        {
            strRet=m_aggregate->Pop(m_current);
        }
        return strRet;
    }
    bool IsDone()
    {
        return ((m_current>=m_aggregate->Count())?true:false);
    }
    object CurrentItem()
    {
        return m_aggregate->Pop(m_current);
    }
};
//ConcreteAggregate具體彙集類，繼承Aggregate
class ConcreteAggregate:public Aggregate
{
private:
    //聲明一個list泛型變量，用於存放聚合對象
    vector<object> items;
    Iterator *m_pIterator;
public:
    ConcreteAggregate():m_pIterator(NULL)
    {
        items.clear();
    }
    ~ConcreteAggregate()
    {
        if(m_pIterator!=NULL)
        {
            delete m_pIterator;
            m_pIterator==NULL;
        }
    }
    Iterator* CreateIterator()
    {
        if(NULL == m_pIterator)
        {
            m_pIterator = new ConcreteIterator(this);
        }
        return m_pIterator;
    }
    int Count()
    {
        return items.size();
    }
    void Push(const object& strValue)
    {
        items.push_back(strValue);
    }
    string Pop(const int nIndex)
    {
        object strRet;
        if(nIndex<Count())
        {
            strRet=items[nIndex];
        }
        return strRet;
    }
};

int main()
{
    ConcreteAggregate *a=new ConcreteAggregate();
    a->Push("大鳥");
    a->Push("小菜");
    a->Push("行李");
    a->Push("老外");
    a->Push("公交內部員工");
    a->Push("小偷");
    Iterator *i=a->CreateIterator();
    object item=i->First();
    while(!i->IsDone())
    {
        cout << i->CurrentItem() << "請買票" << endl;
        i->Next();
    }

    return 0;
}

　　迭代器模式就是分離了集合對象的遍歷行爲，抽象出一個迭代器類來負責，這樣既能夠作到不暴露集合的內部結構，又可以讓外部代碼透明地訪問集合內部的數據。迭代器模式在訪問數組、集合、列表等數據時，尤爲是數據庫數據操做時，是很是廣泛的應用，但因爲它太普通了，因此各類操做語言都對他進行了封裝。