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

[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=13770720612900372&size=800_600&devtype=web&v=1.0.1&rtick=14676146423468&share_qid=108635719&sign=e962522e86fff375be05a576c7aea5c3&[/img]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14666498479405615&size=800_600&devtype=web&v=1.0.1&rtick=14666499174033&share_qid=108635719&sign=732dc65142f295ce7ef15a00ca56727c&[/img]

[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14666498649460277&size=800_600&devtype=web&v=1.0.1&rtick=14666499172480&share_qid=108635719&sign=1c04ac218625b0c0ce76df9c01164786&[/img]

[color=red][b]头文件[/b][/color]

//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

[color=red][b]实现[/b][/color]

#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