设计模式之《迭代器模式》

介绍

迭代器模式(Iterator)，提供-种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。[DP]属于行为型模式之一。

Aggregate：

• 抽象类集合

Iterator(迭代器接口)：

• 该接口必须定义实现迭代功能的最小定义方法集。比如提供hasNext)和next()方法。。

Concretelterator (迭代器实现类):

• 迭代器接口Iterator的实现类。可以根据具体情况加以实现。

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

应用：当你需要对聚集有多种方式遍历时，可以考虑用迭代器模式

 

UML类图

#ifndef SIMPLE_ITERATOR_H
#define SIMPLE_ITERATOR_H

#include <iostream>

using namespace std;

typedef int Object;

#define SIZE 5

/**
 * @brief The Iterator class
 * 迭代器抽象类
 */
class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() = 0;
    virtual Object currentItem() = 0;
};

/**
 * @brief The Aggregate class
 * 集合，聚集抽象类
 */
class Aggregate
{
public:
    virtual Object getItem(int index ) = 0;
    virtual Iterator * createIterator() = 0;
    virtual int getSize() = 0;
};


/**
 * @brief The ConcreteAggregate class
 * 具体聚集（集合）类，继承Aggregate
 */

class ConcreteAggregate: public Aggregate
{
public:
    ConcreteAggregate()
    {
        for (int i=0 ; i < SIZE; i++) {
            obj[i] = i+1;
        }
    }

    ~ConcreteAggregate()
    {

    }

    Object getItem(int index ) override
    {
        return obj[index];
    }

    Iterator * createIterator() override;

    int getSize()
    {
        return SIZE;
    }

private:
    Object obj[SIZE];
};


/**
 * @brief The ConcreteIterator class
 * 具体迭代器类，继承Iterator
 */
class ConcreteIterator : public Iterator
{
public:
    ConcreteIterator( Aggregate *aggregate)
    {
        m_aggregate = aggregate;
        m_current = 0;
    }
    ~ConcreteIterator()
    {
        m_aggregate = nullptr;
        m_current = 0;
    }
    void first() override
    {
        m_current = 0;
    }
    void next() override;
    bool isDone() override;
    Object currentItem() override;
private:
    Aggregate *m_aggregate;
    int m_current ;
};


Iterator * ConcreteAggregate::createIterator()
{
    return new ConcreteIterator(this);
}


void ConcreteIterator::next()
{
   if( m_current < m_aggregate->getSize() )
       m_current ++;
}

bool ConcreteIterator::isDone()
{
    return m_current == m_aggregate->getSize();
}

Object ConcreteIterator::currentItem()
{
    return m_aggregate->getItem(m_current);
}


#endif // SIMPLE_ITERATOR_H

调用：

   //创建一个集合
    ConcreteAggregate *ag = new ConcreteAggregate;
    //通过集合，创建一个遍历这个集合的迭代器

    Iterator *it = ag->createIterator();

    //通过迭代器，遍历集合
    for (;!(it->isDone()); it->next()) {
        cout<<it->currentItem()<<"   \n";
    }

    delete  it;
    delete  ag;