【设计模式】——迭代器模式

迭代器模式(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;
}

　　迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。迭代器模式在访问数组、集合、列表等数据时，尤其是数据库数据操作时，是非常普遍的应用，但由于它太普通了，所以各种操作语言都对他进行了封装。

来源：https://www.cnblogs.com/awy-blog/p/3833034.html