設計模式之迭代器模式

2018-09-23  19:30:03

迭代器模式

　　遍歷：所謂遍歷，就是指把一個集合中的全部元素挨個訪問一遍（這裏的訪問，就是它的字面意思）。

　　迭代器模式（Iterator），提供一種方法順序訪問一個聚合對象中的各個元素，而又不暴露該對象的內部表示。

迭代器模式UML類圖

 

迭代器模式的優缺點

優勢：

　　1.支持不一樣的方式遍歷聚合對象

　　2.迭代器模式簡化了聚合類

　　3.在一個聚合上能夠有多個遍歷

　　4.在迭代器模式中增長新的聚合類和迭代模式都很方便，無需修改源代碼

缺點：

　　1.使用迭代器，將數據存儲和數據遍歷分隔，增長新的聚合類須要增長新的迭代器，類的個數成對增長，這增長了系統的複雜度。

適用場景：

　　1.當須要訪問一個聚合對象，並且無論這些對象是什麼都須要遍歷的時候，就能夠考慮使用迭代器模式。

　　2.當須要對集合有多種方式遍歷時，能夠考慮使用迭代器模式，也就是說迭代器須要爲遍歷不一樣結構提供諸如：開始、下一個、是否結束、當前哪一項等統一的接口

　　3.具體迭代器類的存在是爲了提供對結構的多種遍歷方式的支持。

　　迭代器（Iterator）模式分離了集合對象的遍歷行爲，抽象出一個迭代器類來負責，這樣既能夠作到不暴露集合的內部結構，又能夠讓外部代碼透明的訪問集合內部的數據。

代碼示例

#include <iostream>
#include <string>
#include <vector>

using namespace std;


class Iterator
{
public:
    Iterator(){};
    virtual ~Iterator(){};
    virtual string First() = 0;
    virtual string Next() = 0;
    virtual string GetCur() = 0;
    virtual bool IsEnd() = 0;
};

class Aggregate
{
public:
    virtual int Count() = 0;
    virtual void Push(const string& strValue)=0;
    virtual string Pop(const int nIndex)=0;
    virtual Iterator* CreateIterator() = 0;
};

class ConcreteIterator : public Iterator
{
public:
    ConcreteIterator(Aggregate* pAggregate):m_nCurrent(0),Iterator()
    {
        m_Aggregate = pAggregate;
    }
    string First()
    {
        return m_Aggregate->Pop(0);
    }
    string Next()
    {
        string strRet;
        m_nCurrent++;
        if(m_nCurrent < m_Aggregate->Count())
        {
            strRet = m_Aggregate->Pop(m_nCurrent);
        }
        return strRet;
    }
    string GetCur()
    {
        return m_Aggregate->Pop(m_nCurrent);
    }
    bool IsEnd()
    {
        return ((m_nCurrent >= m_Aggregate->Count()) ? true: false);
    }
private:
    Aggregate* m_Aggregate{nullptr};
    int m_nCurrent{0};
};

class ConcreteAggregate : public Aggregate
{
public:
    ConcreteAggregate():m_pIterator(NULL)
    {
        m_vecItems.clear();
    }
    ~ConcreteAggregate()
    {
        if(NULL != m_pIterator)
        {
            delete m_pIterator;
            m_pIterator = NULL;
        }
    }
    Iterator* CreateIterator()
    {
        if(NULL == m_pIterator)
        {
            m_pIterator = new ConcreteIterator(this);
        }
        return m_pIterator;
    }
    int Count()
    {
        return m_vecItems.size();
    }
    void Push(const string& strValue)
    {
        m_vecItems.push_back(strValue);
    }
    string Pop(const int nIndex)
    {
        string strRet;
        if(nIndex < Count())
        {
            strRet = m_vecItems[nIndex];
        }
        return strRet;
    }
private:
    vector<string> m_vecItems;
    Iterator* m_pIterator;


};

Iterator Pattern

#include "IteratorPatter.h"

int main()
{
    ConcreteAggregate* pName = NULL;
    pName = new ConcreteAggregate();
    if(NULL != pName)
    {
        pName->Push("1");
        pName->Push("2");
        pName->Push("3");
    }
    Iterator* iter = NULL;
    iter = pName->CreateIterator();
    if(NULL != iter)
    {
        string strItem = iter->First();
        while(!iter->IsEnd())
        {
            cout << iter->GetCur() << " is ok" << endl;
            iter->Next();
        }
    }

    return 0;
}

Client