设计模式之迭代器模式

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