前言

    在寻常生活其中，我们常常要使用到迭代器。比如在观看一组图片时，我们常常使用遍历的方法观看，我们并不须要详细研究图片的结构，仅仅须要遍历，而且能够将当前的遍历状态记录下来，下次观看时能够从之前的遍历终止点開始继续。

    即在面向对象的软件设计中，我们常常会遇到一类集合对象。这类集合对象的内部结构可能有着各种各样的实现。可是最重要的是有两点是须要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则。所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为。抽象出一个迭代器类来负责，这样既能够做到不暴露集合的内部结构，又可让外部代码透明的訪问集合内部的数据。

1.别人可能要用到我们的容器元素，使用迭代器能够訪问各个元素而不暴露容器内部细节。

2.能够有一种以上的方式遍历容器元素

3.同一时候对容器元素进行多次遍历。

由于迭代器会保存当前的遍历状态，所以能够通过迭代器模式来达到这样的需求。

迭代器（Iterator）模式

    又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法訪问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

UML图：

Iterator：定义迭代器訪问和遍历元素的接口；

ConcreteIterator：实现详细的迭代器。

Aggregate：定义的容器。创建对应迭代器对象的接口；

ConcreteAggregate：详细的容器实现创建对应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。

代码例如以下：

#include 
     
        #include 
      
         using namespace std;  template
       
          class Iterator; template
        
          class ConcreteIterator;//集合角色template
         
           class Aggregate{public:  	virtual ConcreteIterator
          
            begin()=0; virtual ConcreteIterator
           
             end()=0; virtual ~Aggregate(){} };template
            
              class ConcreteAggregate:public Aggregate
             
               { vector
              
               data; public: ConcreteAggregate() { data.push_back(1); data.push_back(2); data.push_back(3); } virtual ConcreteIterator
               
                 begin() { return ConcreteIterator
                
                 (this); } virtual ConcreteIterator
                 
                   end() { return ConcreteIterator
                  
                   (this,data.size()); } T& operator[](int index) { return data[index]; } };template
                   
                     class Iterator { public: //virtual Iterator
                    
                     & operator ++(int); //virtual Iterator
                     
                      & operator ++(); // //virtual const T& operator*() const; virtual T& getCur()=0;}; template
                      
                        class ConcreteIterator:public Iterator
                       
                        {private: ConcreteAggregate
                        
                         * m_pAG; int cur; public: ConcreteIterator(ConcreteAggregate
                         
                          *a):m_pAG(a),cur(0){} ConcreteIterator(ConcreteAggregate
                          
                           *a,int len):m_pAG(a),cur(len){} ConcreteIterator
                           
                            & operator ++(int) { ConcreteIterator
                            
                              ret(*this); ++*this; return ret; } ConcreteIterator
                             
                              & operator ++() { cur++; return *this; } ConcreteIterator
                              
                               & operator =(ConcreteIterator
                               
                                & rhs) { this=rhs； return *this; } bool operator !=(ConcreteIterator
                                
                                 & rhs) { return this->cur!=rhs.cur; } T& getCur() { T temp=(*m_pAG)[cur]; return temp; }};int main() { Aggregate
                                 
                                   * aggr =new ConcreteAggregate
                                  
                                   (); ConcreteIterator
                                   
                                     it=aggr->begin(); //it++; for(;it!=aggr->end();it++) { cout<
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     

感觉自己写的有点问题。主要想重载操作符++跟*之类的。老是不成功，想做成跟c++里面的迭代器一样，可是详细里面里面怎么实现还不清楚。要是谁有资料能把链接发给我看看就谢谢啦~

版权声明：本文博主原创文章。博客，未经同意不得转载。