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

快来打我* 2022-04-11 05:43 239阅读 0赞

\[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