[行为型模式]迭代器模式的理解

头文件

//IteratorPattern.h

#ifndef INTERATOR_PATTERN_H
#define INTERATOR_PATTERN_H

#include <Windows.h>
#include <iostream>
#include <vector>
using namespace std;

namespace IteratorPattern
{
    template<class Item>
    class Iterator
    {
    public:
        virtual void First()=0;
        virtual void Next()=0;
        virtual Item* CurrentItem()=0;
        virtual bool IsDone()=0;
        virtual ~Iterator();
    };

    template<class Item>
    class ConcreteAggregate;

    template<class Item>
    class ConcreteIterator : public Iterator <Item>
    {
    public:
        ConcreteIterator(ConcreteAggregate<Item>* pAggr);
        virtual void First();
        virtual void Next();
        virtual Item* CurrentItem();
        virtual bool IsDone();

    private:
        ConcreteAggregate<Item>* m_pAggr;
        int m_nCur;

    };

    template<class Item>
    class Aggregate
    {
    public:
        virtual Iterator<Item>* CreateIterator()=0;
        virtual ~Aggregate();
    };

    template<class Item>
    class ConcreteAggregate:public Aggregate<Item>
    {
    public:
        ConcreteAggregate();
        virtual Iterator<Item>* CreateIterator();
        Item& operator[](int index);
        int GetLen();

    private:
        vector<Item >m_Data;
    };

    //////////////////////////////////////////////////////////////////////////
    void IteratorPattern_Test();
}

#endif

实现

#include "IteratorPattern.h"
#include <iostream>
using namespace std;

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

namespace IteratorPattern
{
    //////////////////////////////////////////////////////////////////////////
    template<class Item>
    Iterator<Item>::~Iterator(){}

    template<class Item>
    ConcreteIterator<Item>::ConcreteIterator(ConcreteAggregate<Item>*a)
        : m_pAggr(a)
        , m_nCur(0)
    {}

    template<class Item>
    void ConcreteIterator<Item>::First()
    {
        m_nCur=0;
    }

    template<class Item>
    void ConcreteIterator<Item>::Next()
    {
        if(m_nCur<m_pAggr->GetLen())
            m_nCur++;
    }

    template<class Item>
    Item* ConcreteIterator<Item>::CurrentItem()
    {
        if(m_nCur<m_pAggr->GetLen())
            return &(*m_pAggr)[m_nCur];
        else
            return NULL;
    }

    template<class Item>
    bool ConcreteIterator<Item>::IsDone()
    {
        return (m_nCur>=m_pAggr->GetLen());
    }

    //////////////////////////////////////////////////////////////////////////
    template<class Item>
    Aggregate<Item>::~Aggregate(){}

    template<class Item>
    ConcreteAggregate<Item>::ConcreteAggregate()
    {
        m_Data.push_back(1);
        m_Data.push_back(2);
        m_Data.push_back(3);
    }
    
    template<class Item>
    Iterator<Item>* ConcreteAggregate<Item>::CreateIterator()
    {
        return new ConcreteIterator<Item>(this);
    }

    template<class Item>
    Item& ConcreteAggregate<Item>::operator[](int index)
    {
        return m_Data[index];
    }

    template<class Item>
    int ConcreteAggregate<Item>::GetLen()
    {
        return m_Data.size();
    }

    //////////////////////////////////////////////////////////////////////////
    void IteratorPattern_Test()
    {
        Aggregate<int> * m_pAggr =new ConcreteAggregate<int>();
        Iterator<int> *it=m_pAggr->CreateIterator();

        for(it->First();!it->IsDone();it->Next())
        {
            cout<<*(it->CurrentItem())<<endl;
        }

        delete it;
        delete m_pAggr;
    }
}

1
2
3