行为型模型 迭代器模式

GOOD：提供一种方法顺序访问一个聚敛对象的各个元素，而又不暴露该对象的内部表示。

为遍历不同的聚集结构提供如开始，下一个，是否结束，当前一项等统一接口。

Iterator（迭代器接口）：
        该接口必须定义实现迭代功能的最小定义方法集
        比如提供hasNext()和next()方法。
ConcreteIterator（迭代器实现类）：
        迭代器接口Iterator的实现类。可以根据具体情况加以实现。
Aggregate（容器接口）：
        定义基本功能以及提供类似Iterator iterator()的方法。
concreteAggregate（容器实现类）：
        容器接口的实现类。必须实现Iterator iterator()方法。

/**
 * 行为型模型 迭代器模式
 * Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。
 *
 */

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

typedef int Object;
#define SIZE 5

class MyIterator
{
public:
    virtual void First() = 0;
    virtual void Next() = 0;
    virtual bool IsDone() = 0;
    virtual Object Currentitem() = 0;
    virtual ~MyIterator() {}
};

class Aggregate
{
public:
    virtual Object getItem(int index) = 0;
    virtual MyIterator *CreateIterator() = 0;
    virtual int getSize() = 0;
    virtual ~Aggregate() {}
};

class ContreteIierator: public MyIterator
{
public:
    ContreteIierator(Aggregate *ag)
    {
        _ag = ag;
        _idx = 0;
    }
    ~ContreteIierator()
    {
        _ag = nullptr;
        _idx = 0;
    }
    virtual void First() override
    {
        _idx = 0;
    }
    virtual void Next() override
    {
        if (_idx < _ag->getSize())
        {
            _idx++;
        }
    }
    virtual bool IsDone() override
    {
        return (_idx == _ag->getSize());
    }
    virtual Object Currentitem() override
    {
        return _ag->getItem(_idx);
    }
private:
    int _idx;
    Aggregate * _ag;
};

class ConcreateAggregate: public Aggregate
{
public:
    ConcreateAggregate()
    {
        for (int i = 0; i < SIZE; i++)
        {
            object[i] = i+1;
        }
    }
    ~ConcreateAggregate()
    {
        for (int i = 0; i < SIZE; i++)
        {
            object[i] = 0;
        }
    }
    virtual Object getItem(int index) override
    {
        return object[index];
    }
    virtual MyIterator *CreateIterator() override
    {
        return new ContreteIierator(this);
    }
    virtual int getSize() override
    {
        return SIZE;
    }

private:
    Object object[SIZE];
};

void mytest()
{
    // 创建一个集合
    Aggregate *ag = new ConcreateAggregate();
    // 创建一个遍历这个集合的迭代器
    MyIterator *it = ag->CreateIterator();

    // 通过迭代器遍历集合
    for (; !(it->IsDone()); it->Next())
    {
        std::cout << it->Currentitem() << " ";
    }
    std::cout << std::endl;

    // 清理相关资源
    delete it;
    delete ag;

    return;
}

int main()
{
    mytest();

    system("pause");
    return 0;
}