【设计模式】之二十三种设计模式--迭代器模式

迭代器模式

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
(它提供一种方法访问一个容器对象中各个元素,而又不需暴露该对象的内部细节。)

通用类图

抽象迭代器类，定义访问和遍历元素的接口
具体迭代器类，继承抽象迭代器类，实现接口方法，与具体容器类关联
抽象容器类，提供创建具体迭代器的接口
具体容器类，继承抽象容器类，实现方法，创建初容纳迭代器的对象，使用具体迭代器类

通用源码

//抽象迭代器类
template <typename T>
class Iterator {
public:
    virtual T next() = 0;
    virtual bool remove() = 0;
    virtual bool hasxNext() = 0;
};
//具体迭代器类
template <typename T>
class ConcreteIterator: public Iterator<T> {
public:
    ConcreteIterator(vector<T> v): vt(v) { }
    bool hasxNext() {
        if(cursor == vt.size()) return false;
        else return true;
    }
    T next() {
        T t;
        if(hasxNext()) t = vt[cursor++];
        return t;
    }
    bool remove() {
        vt.erase(vt.begin()+cursor++);
        return true;
    }

private:
    vector<T> vt;
    int cursor = 0;
};
//抽象容器类
template <typename T>
class Aggregate {
public:
    virtual void add(T) = 0;
    virtual void remove(T) = 0;
    virtual Iterator<T>* iter() = 0;
};
//具体容器类
template <typename T>
class ConcreteAggregate: public Aggregate<T> {
public:
    void add(T t) {
        vt.push_back(t);
    }
    void remove(T t) {
        auto iter = find(vt.begin(), vt.end(), t);
        vt.erase(iter);
    }
    Iterator<T>* iter() {
        return new ConcreteIterator<T>(vt);
    }
private:
    vector<T> vt;
};

应用

迭代器模式已经被各种容器已经内部实现了，这里讲述的是迭代器的内部大概是怎么实现的，它的思想是如何。
在一般的开发中，不需要自己再次实现迭代器模式

示例代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
//抽象迭代器类
template <typename T>
class Iterator {
public:
    virtual T next() = 0;
    virtual bool remove() = 0;
    virtual bool hasxNext() = 0;
};
//具体迭代器类
template <typename T>
class ConcreteIterator: public Iterator<T> {
public:
    ConcreteIterator(vector<T> v): vt(v) { }
    bool hasxNext() {
        if(cursor == vt.size()) return false;
        else return true;
    }
    T next() {
        T t;
        if(hasxNext()) t = vt[cursor++];
        return t;
    }
    bool remove() {
        vt.erase(vt.begin()+cursor++);
        return true;
    }

private:
    vector<T> vt;
    int cursor = 0;
};
//抽象容器类
template <typename T>
class Aggregate {
public:
    virtual void add(T) = 0;
    virtual void remove(T) = 0;
    virtual Iterator<T>* iter() = 0;
};
//具体容器类
template <typename T>
class ConcreteAggregate: public Aggregate<T> {
public:
    void add(T t) {
        vt.push_back(t);
    }
    void remove(T t) {
        auto iter = find(vt.begin(), vt.end(), t);
        vt.erase(iter);
    }
    Iterator<T>* iter() {
        return new ConcreteIterator<T>(vt);
    }
private:
    vector<T> vt;
};

int main() {
    Aggregate<int>* agg = new ConcreteAggregate<int>();
    agg->add(1);
    agg->add(3);
    agg->add(2);
    Iterator<int>* it = agg->iter();
    while(it->hasxNext()) {
        cout << it->next() << endl;
    }
    return 0;
}