迭代器模式

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

Iterator 抽象迭代器：定义访问和遍历元素的接口。

ConcreteIterator 具体迭代器：实现抽象迭代器的接口，完成对聚合对象的遍历，同时在迭代器中通过游标来记录在聚合对象中所出的当前位置。

Aggregate 抽象聚合类：用于存储和管理元素对象，声明createIterator方法用于创建一个Iterator对象。

ConcreteAggregate 具体聚合类：实现createIterator()方法。

二 C++实现
Iterator.h

#pragma once 

#include <iterator>
#include <vector>
#include <set>


template<class T, class U>
class Iterator{
public:
    typedef typename std::vector<T>::iterator iter_type;
    Iterator(U *pData):m_pData(pData){
        m_it = m_pData->m_data.begin();
    }

    void first(){
        m_it = m_pData->m_data.begin();
    }

    void next(){
        m_it++;
    }

    bool isDone(){
        return (m_it == m_pData->m_data.end());
    }

    iter_type current(){
        return m_it;
    }

private:
    U *m_pData;
    iter_type m_it;
};

template<class T, class U, class A>
class SetIterator
{
public:
    typedef typename std::set<T, U>::iterator iter_type;
    SetIterator(A * _pData):m_pData(_pData){
        m_it = m_pData->m_data.begin();
    }

    void first(){
        m_it = m_pData->m_data.begin();
    }

    void next(){
        m_it++;
    }

    bool is_Done(){
        return (m_it == m_pData->m_data.end());
    }

    iter_type current(){
        return m_it;
    }

private:
    A * m_pData;
    iter_type m_it;
};

Aggregate.h

#pragma once

#include <set>
#include "Iterator.h"


template<class T>
class Aggregate
{
private:
    std::vector<T> m_data;
    friend class Iterator<T, Aggregate>;

public:
    void add(T a){
        m_data.push_back(a);
    }

    Iterator<T, Aggregate> * create_iterator(){
        return new Iterator<T, Aggregate>(this);
    }
};

template <class T, class U>
class AggregateSet
{
private:
    friend class SetIterator<T, U, AggregateSet>;

    std::set<T,U> m_data;

public:
    void add(T a){
        m_data.insert(a);
    }

    SetIterator<T, U, AggregateSet> *create_iterator(){
        return new SetIterator<T, U, AggregateSet>(this);
    }

    void Print(){
        copy(m_data.begin(), m_data.end(),std::ostream_iterator<T>(std::cout,"\n"));
    }
};

main.cpp

#include <iostream>
#include <string>
#include <ostream>

#include "Aggregate.h"

using namespace std;


class Money
{
private:
    int m_data;

public:
    Money(int a=0):m_data(a){}

    void setMoney(int a){
        m_data = a;
    }

    int getMoney(){
        return m_data;
    }

    virtual ~Money(){}
};

int main()
{
    std::cout << "------Iterator with int------" << std::endl;
    Aggregate<int> agg;
    for(int i=0;i<10;i++){
        agg.add(i);
    }
    Iterator<int, Aggregate<int>> *it = agg.create_iterator();
    for(it->first();!it->isDone();it->next()){
        std::cout << *it->current() << std::endl;
    }

    std::cout << "------Iterator with money------" << std::endl;
    Aggregate<Money> agg2;
    Money a(1000), b(100), c(10);
    agg2.add(a);
    agg2.add(b);
    agg2.add(c);
    Iterator<Money, Aggregate<Money>> *it2 = agg2.create_iterator();
    for(it2->first();!it2->isDone();it2->next()){
        std::cout << it2->current()->getMoney() << std::endl;
    }
    system("pause");
    return 0;
}

运行结果