迭代器模式(Iterator)

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

要点：
1.迭代器允许访问聚合的元素，而不需要暴露它的内部结构。
2.迭代器将遍历聚合的工作封装进一个对象中
3.当使用迭代器的时候，我们依赖聚合提供遍历
4.迭代器提供了一个通用的接口，让我们遍历聚合的项时，就可以使用多态机制
5.我们应该努力让一个类只分配一个责任
6.组合模式提供一个结构，可同时包容个别对象和组合对象
7.组合模式允许客户对个别对象以及组合对象一视同仁
8.组合结构内的任意对象称为组件，组件可以是组合，也可以是叶节点
9.在实现组合模式时，有许多设计上的折衷。要根据需要平衡透明性和安全性

设计原则：一个类应该只有一个引起变化的原因



Iterator.h

#ifndef ITERATOR_H
#define ITERATOR_H

#include <list>
#include <assert.h>
using namespace std;

template<typename T>
class Iterator{
public:
    virtual T next()=0;
    virtual bool hasNext()=0;
};

template<typename T>
class ArrayIterator:public Iterator<T>{
private:
    T* t;
    int mIndex;
    int mMaxSize;
public:
    ArrayIterator(T* arr,int size)
    {
        t = arr;
        mMaxSize = size;
        mIndex = 0;
    }
    T next(){
        T data =  t[mIndex];
        mIndex++;
        return data;
    }
    bool hasNext(){
        if(mIndex<mMaxSize)
            return true;
        return false;
    }
};

template<typename T>
class ListIterator:public Iterator<T>{
private:
    list<T>* mList;
    int mIndex;
    typename list<T>::iterator mIter;
public:
    ListIterator(list<T>* lst){
        mList = lst;
        mIndex = 0;
        mIter = mList->begin();
    }
    T next(){
        T data = *mIter;
        ++mIter;
        return data;
    }
    bool hasNext(){
        if(mIter!=mList->end()){
            return true;
        }
        return false;
    }
};
#endif // ITERATOR_H

ContainerClass.h

#ifndef CONTAINERCLASS_H
#define CONTAINERCLASS_H
#include "Iterator.h"

template<typename T>
class ContainerClass{
public:
    virtual Iterator<T>* createIterator()=0;
    virtual void addElement(T elem)=0;
};

template<typename T>
class ArrayClass:public ContainerClass<T>{
private:
    T* mArray;
    int mMaxSize;
    int mIndex;
public:
    ArrayClass(int sz){
        mArray = new T[sz];
        mMaxSize = sz;
        mIndex = 0;
    }
    ArrayIterator<T>* createIterator(){
        return new ArrayIterator<T>(mArray,mMaxSize);
    }
    void addElement(T elem){
        assert(mIndex<mMaxSize);
        mArray[mIndex] = elem;
        mIndex++;
    }
};

template<typename T>
class ListClass:public ContainerClass<T>{
private:
    list<T>* mList;
public:
    ListClass(){
        mList = new list<T>;
    }
    ListIterator<T>* createIterator(){
        return new ListIterator<T>(mList);
    }
    void addElement(T elem){
        mList->push_back(elem);
    }
};

#endif // CONTAINERCLASS_H

main.cpp

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

int main()
{
    ArrayClass<int> arr(10);
    ListClass<double> lst;
    for(int i=0;i<10;i++){
        arr.addElement(i);
        lst.addElement(i+0.5);
    }
    ArrayIterator<int>* arrIter = arr.createIterator();
    while(arrIter->hasNext()){
        cout << arrIter->next() << " ";
    }
    cout << endl;
    ListIterator<double>* listIter = lst.createIterator();
    while(listIter->hasNext()){
        cout << listIter->next() << " ";
    }
    cout << endl;
}


0 1 2 3 4 5 6 7 8 9 
0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5