016 --- 第20章 迭代器模式

简述：

　　迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

　　迭代器模式包括：抽象聚集类、具体聚集类、抽象迭代类、具体迭代类。

　　　　抽象聚集类：封装一个抽象迭代类对象。

　　　　具体聚集类：继承自抽象聚集类。

　　　　抽象迭代类：用于定义得到开始对象、得到下一个对象、判断是否到结尾、当前对象等抽象方法，统一接口。

　　　　具体迭代类：继承自抽象迭代类，实现开始、下一个、是否结尾、当前对象等方法。

 

应用场景：类似于迭代器，当需要实现多种遍历方式时，可以使用迭代器模式

 

注：开发环境调整为VS2017，操作系统win11

迭代器模式：

 

#include <iostream>
#include <string>
#include <list>
using namespace std;

class CObject
{
public:
    string m_szData;

public:
    CObject(string szData) : m_szData(szData){}
};

// 抽象迭代器类
class CIterator
{
public:
    virtual CObject* First() = 0;
    virtual CObject* Next() = 0;
    virtual bool IsDone() = 0;
    virtual CObject* CurrentItem() = 0;
};

// 抽象聚集类
class CAggregate
{
public:
    virtual CIterator* CreateIterator(CIterator* pIterator) = 0;
};

// 具体聚集类
class CConcreteAggregate : public CAggregate
{
private:
    list<CObject*> m_lstItems;
    CIterator* m_pIterator;

public:
    virtual CIterator* CreateIterator(CIterator* pIterator)
    {
        m_pIterator = pIterator;
        return m_pIterator;
    }

    int Count() { return m_lstItems.size(); }

    CObject* operator[](int nIndex)
    {
        CObject* pObj = NULL;
        if (nIndex > m_lstItems.size() - 1)
            return pObj;
        
        list<CObject*>::iterator ite = m_lstItems.begin();
        int n = 0;
        while (ite != m_lstItems.end())
        {
            if (n == nIndex)
            {
                pObj = (*ite);
                break;
            }

            n++;
            ite++;
        }

        return pObj;
    }

    list<CObject*>& GetList() { return m_lstItems; }
};

// 具体迭代类
class CConcreteIterator : public CIterator
{
private:
    CConcreteAggregate* m_pAggregate;
    int m_nCurrent;

public:
    CConcreteIterator(CConcreteAggregate* pAggregate)
    {
        m_pAggregate = pAggregate;
        m_nCurrent = 0;
    }

    virtual CObject* First() { return (*m_pAggregate)[0]; }

    virtual CObject* Next()
    {
        CObject* pObject = NULL;
        m_nCurrent++;
        if (m_nCurrent < m_pAggregate->Count())
            pObject = (*m_pAggregate)[m_nCurrent];
        
        return pObject;
    }

    virtual bool IsDone() { return m_nCurrent >= m_pAggregate->Count() ? true : false; }

    virtual CObject* CurrentItem() { return (*m_pAggregate)[m_nCurrent]; }
};

// 具体反向迭代类
class CConcreteIteratorDesc : CIterator
{
private:
    CConcreteAggregate* m_pAggregate;
    int m_nCurrent;

public:
    CConcreteIteratorDesc(CConcreteAggregate* pAggregate)
    {
        m_pAggregate = pAggregate;
        m_nCurrent = m_pAggregate->Count() - 1;
    }

    virtual CObject* First() { return (*m_pAggregate)[m_pAggregate->Count() - 1]; }

    virtual CObject* Next()
    {
        CObject* pObject = NULL;
        m_nCurrent--;
        if (m_nCurrent < m_pAggregate->Count())
            pObject = (*m_pAggregate)[m_nCurrent];
        
        return pObject;
    }

    virtual bool IsDone() { return m_nCurrent < 0 ? true : false; }

    virtual CObject* CurrentItem() { return (*m_pAggregate)[m_nCurrent]; }
};

int main()
{
    CConcreteAggregate Aggregate;
    CObject obj("GGG"), obj1("HHH"), obj2("LLL");
    Aggregate.GetList().push_back(&obj);
    Aggregate.GetList().push_back(&obj1);
    Aggregate.GetList().push_back(&obj2);

    //CConcreteIterator Iterator(&Aggregate);
    CConcreteIteratorDesc Iterator(&Aggregate);
    CObject* pObj = Iterator.First();
    while (!Iterator.IsDone())
    {
        cout << Iterator.CurrentItem()->m_szData << " 请买车票！" << endl;
        Iterator.Next();
    }

    system("pause");
    return 0;
}

输出结果：