迭代器模式

模式定义

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

模式动机

• 一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑迭代器模式。
• 你需要对聚集有多种方式遍历时，可以考虑用迭代器模式。
• 为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

UML类图

源码实现

• aggregate.h

#include <string>
#include <vector>

class Aggregate
{
public:
    Aggregate();
    void insert(std::string obj);
    virtual ~Aggregate();
    virtual int Count() = 0;
    virtual std::string& operator[](int i) = 0;

protected:
    std::vector<std::string>        m_Vec;
};

• aggregate.cpp

#include "aggregate.h"

Aggregate::Aggregate()
{

}

Aggregate::~Aggregate()
{

}

void Aggregate::insert(std::string obj)
{
    m_Vec.push_back(obj);
}

• iterator.h

#include "aggregate.h"

class Iterator
{
public:
    Iterator(Aggregate* aggregate);
    virtual ~Iterator();
    virtual std::string First() = 0;
    virtual std::string Next() = 0;
    virtual bool IsDone() = 0;
    virtual std::string CurrentItem() = 0;

protected:
    Aggregate*      m_Aggregate;
};

• concreteIterator.h

#include "iterator.h"
#include "aggregate.h"

class ConcreteIterator : public Iterator
{
public:
    ConcreteIterator(Aggregate* aggredate);
    std::string First() override;
    std::string Next() override;
    bool IsDone() override;
    std::string CurrentItem() override;

private:
    int     m_CurrentIndex;
};

• concreteIterator.cpp

#include <iostream>
#include "concreteiterator.h"

ConcreteIterator::ConcreteIterator(Aggregate* aggredate)
    :Iterator(aggredate)
{
    m_CurrentIndex = 0;
}

std::string ConcreteIterator::First()
{
    return (*m_Aggregate)[0];
}

std::string ConcreteIterator::Next()
{
    m_CurrentIndex++;
    if(m_CurrentIndex < m_Aggregate->Count())
        return (*m_Aggregate)[m_CurrentIndex];
    else
        return "";
}

bool ConcreteIterator::IsDone()
{
    return m_CurrentIndex >= m_Aggregate->Count() ? true : false;
}

std::string ConcreteIterator::CurrentItem()
{
    return (*m_Aggregate)[m_CurrentIndex];
}

• concreteAggregate.h

#include <aggregate.h>
#include <string>
#include "iterator.h"

class ConcreteAggregate : public Aggregate
{
public:
    ConcreteAggregate();
    int Count() override;
    std::string &operator[](int i) override;

private:
    Iterator*       m_Iterator;
};

• concreteAggregate.cpp

#include "concreteaggregate.h"

ConcreteAggregate::ConcreteAggregate()
{
}

int ConcreteAggregate::Count()
{
    return static_cast<int>(m_Vec.size());
}

std::string& ConcreteAggregate::operator[](int i)
{
    return m_Vec[size_t(i)];
}

• main.cpp

#include <iostream>
#include "concreteaggregate.h"
#include "concreteiterator.h"
using namespace std;

int main()
{
    Aggregate* agt =  new ConcreteAggregate();
    agt->insert("王二麻子");
    agt->insert("张二蛋子");
    agt->insert("李二狗子");
    agt->insert("王小花儿");

    Iterator* i = new ConcreteIterator(agt);
    while(!i->IsDone())
    {
        std::cout << i->CurrentItem() << " 请出示您的车票!" << std::endl;
        i->Next();
    }
    return 0;
}

• 运行结果

王二麻子 请出示您的车票!

张二蛋子 请出示您的车票!

李二狗子 请出示您的车票!

王小花儿 请出示您的车票!

优点

迭代器模式的优点

• 迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。

缺点

模式的缺点