设计模式---数据结构模式之迭代器模式（Iterate）

一：概念

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

在应用Iterator模式之前，首先应该明白Iterator模式用来解决什么问题。或者说，如果不使用Iterator模式，会存在什么问题？

1.由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法 
2.让调用者自己实现遍历。直接暴露数据细节给外部。 

以上方法1与方法2都可以实现对遍历，这样有问题呢？ 

1，容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能。 
2，往往容器在实现遍历的过程中，需要保存遍历状态，当跟元素的添加删除等功能夹杂在一起，很容易引起混乱和程序运行错误等。

Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。

所以，Iterator模式的应用场景可以归纳为满足以下几个条件：

1.访问容器中包含的内部对象；
2.按顺序访问

二：动机

在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明的访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。

使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“因对变化中的集合对象”提供了一种优雅的方式。

三：模式定义

提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露（隔离变化，稳定）该对象的内部表示。

                                                                                    ——《设计模式》GoF

这种方式在C++现在来说已经过时了，因为泛型编程和STL中实现了迭代器。
迭代器模式最核心缺点就是出现在面向对象上，虚函数调用是有性能成本的，需要绕一个虚函数的表指针，然后找到函数地址，才能去调用，要经过指针间接运算。当循环次数太高后，性能就会被削减。
泛型编程中优点：迭代器是使用模板来实现的，而模板（也是一种多态技术），但是他实现的多态是编译时多态，编译器会在编译时判断具体是调用哪段代码。
虚函数是运行时多态，运行时多态性能低于编译时多态，编译时多态不需要计算他的地址了，因此STL性能高于面向对象模式迭代器，功能也更多。

四：类图（结构）

五：代码讲解

（一）Iterator基类

template<typename T>
class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const = 0;
    virtual T& current() = 0;
};

（二）基类Collection返回迭代器

template<typename T>
class MyCollection{
    
public:
    
    Iterator<T> GetIterator(){
        //...
    }
    
};

（三）子类CollectionIterator实现迭代方法

template<typename T>
class CollectionIterator : public Iterator<T>{
    MyCollection<T> mc;
public:
    
    CollectionIterator(const MyCollection<T> & c): mc(c){ }
    
    void first() override {
        
    }
    void next() override {
        
    }
    bool isDone() const override{
        
    }
    T& current() override{
        
    }
};

（四）进行调用

void MyAlgorithm()
{
    MyCollection<int> mc;
    
    Iterator<int> iter= mc.GetIterator();
    
    for (iter.first(); !iter.isDone(); iter.next()){
        cout << iter.current() << endl;
    }
    
}

六：要点总结

（一）Java，C#类库是按照上面实现，因为毕竟没有编译时多态，现在C++基本没有这种实现，随着技术的发展，有些设计模式会过时，但是思想不会过时。

（二）迭代抽象：访问一个聚合对象的内容而无需暴露他的内部表示

（三）迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

（四）迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。

七：案例实现 

（一）实现迭代器基类

class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const= 0;
    virtual int& current() = 0;
    virtual ~Iterator(){}
};

（二）实现聚合基类

class Aggregate
{
public:
    virtual Iterator* CreateIntertor() = 0;
    virtual int getSize() = 0;
    virtual int getItem(int index) = 0;
    virtual ~Aggregate(){}
};

（三）实现具体迭代器子类

class ConcreteIterator :public Iterator
{
private:
    Aggregate* _ag;
    int _idx;
public:
    ConcreteIterator(Aggregate* ag)
    {
        _ag = ag;
        _idx = 0;
    }

    virtual void first()
    {
        _idx = 0;
    }

    virtual void next()
    {
        if (_idx<_ag->getSize())
            _idx++;
    }

    virtual bool isDone() const
    {
        return _idx == _ag->getSize();
    }

    virtual int current()
    {
        return _ag->getItem(_idx);
    }
};

（四）实现聚合子类

class ConcreteAggregate :public Aggregate
{
private:
    int *Object;
    int size;
public:
    ConcreteAggregate(int size)
    {
        Object = (int *)malloc(size*sizeof(int));

        for (int i = 0; i < size; i++)
            Object[i] = i*i;

        this->size = size;
    }

    virtual Iterator* CreateIntertor()
    {
        return new ConcreteIterator(this);
    }

    virtual int getSize()
    {
        return this->size;
    }

    virtual int getItem(int index)
    {
        return this->Object[index];
    }

    ~ConcreteAggregate()
    {
        delete Object;
    }
};

（五）结果测试

int main()
{
    Aggregate* ag = new ConcreteAggregate(10);
    Iterator* it = ag->CreateIntertor();

    for (it; !it->isDone(); it->next())
        cout << it->current() << endl;

    delete it;
    delete ag;

    system("pause");
    return 0;
}

作为迭代器，最好设置为模板类吧

#include <iostream>
#include <string>

using namespace std;

template<typename T>
class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const= 0;
    virtual T& current() = 0;
    virtual ~Iterator(){}
};

template<typename T>
class Aggregate
{
public:
    virtual Iterator<T>* CreateIntertor() = 0;
    virtual int getSize() = 0;
    virtual T& getItem(int index) = 0;
    virtual ~Aggregate(){}
};

template<typename T>
class ConcreteIterator :public Iterator<T>
{
private:
    Aggregate<T>* _ag;
    int _idx;
public:
    ConcreteIterator(Aggregate<T>* ag)
    {
        _ag = ag;
        _idx = 0;
    }

    virtual void first()
    {
        _idx = 0;
    }

    virtual void next()
    {
        if (_idx<_ag->getSize())
            _idx++;
    }

    virtual bool isDone() const
    {
        return _idx == _ag->getSize();
    }

    virtual T& current()
    {
        return _ag->getItem(_idx);
    }
};

template<typename T>
class ConcreteAggregate :public Aggregate<T>
{
private:
    T *Object;
    int size;
public:
    ConcreteAggregate(int size)
    {
        Object = (T *)malloc(size*sizeof(T));

        for (int i = 0; i < size; i++)
            Object[i] = 65+i;

        this->size = size;
    }

    virtual Iterator<T>* CreateIntertor()
    {
        return new ConcreteIterator<T>(this);
    }

    virtual int getSize()
    {
        return this->size;
    }

    virtual T& getItem(int index)
    {
        return this->Object[index];
    }

    ~ConcreteAggregate()
    {
        delete Object;
    }
};

int main()
{
    Aggregate<char>* ag = new ConcreteAggregate<char>(10);
    Iterator<char>* it = ag->CreateIntertor();

    for (it; !it->isDone(); it->next())
        cout << it->current() << endl;

    delete it;
    delete ag;

    system("pause");
    return 0;
}