[设计模式] 设计模式课程（十八）--迭代器模式

概述

• 属于行为型模式
• 将集合的遍历行为抽取为单独的迭代器对象
• 所有迭代器实现相同的接口，只要有合适的迭代器，客户端代码就能兼容任何类型的集合或遍历算法，如需采用特殊方法遍历集合，创建一个新的迭代器即可，而无需对集合或客户端进行修改
• 集合对象内部结构常常变化各异，但对于这些集合对象，我们希望在不暴露其内部结构的同时，也可以让外部客户代码透明地访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能
• 使用面向对象技术将这种遍历机制抽象为“迭代器模式”为“因对变化中的集合对象”提供了一种优雅的方式
• 提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露（稳定）该对象内部的表示
• 通过迭代器接口，隔离算法和容器之间的变化
• 面向对象（虚函数）实现迭代器，虚函数调用存在性能问题（运行时多态），在迭代器循环中会造成较大损失（绕虚函数表指针找函数地址的运算），故在c++在98年后改用STL泛型编程模板实现迭代器（编译时多态）
• Java、C#类库中依然使用面向对象实现迭代器
• 迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示
• 迭代多样：为遍历不同的集合提供一个统一的接口，从而支持同样的算法在不同集合结构上进行操作
• 健壮性：迭代的同时更改迭代器所在的集合结构，会导致问题
• ConcreteAggregate是具体聚合类（容器，如列表（List）或集合（Set）等），ConcreteIterator是容器对应的迭代器类

场景

• 采用自由行，手机导航，跟团等方式游览一个城市，城市的景点是一个集合，每个游览方式是一个迭代器

结构

• 迭代器接口：声明了遍历集合所需的操作
• 具体迭代器类：实现遍历集合的一种特定算法
• 集合接口：声明一个或多个方法获取与集合兼容的迭代器，返回迭代器接口
• 具体集合类：客户端请求迭代器时返回一个特定的具体迭代器类实体
• 客户端类：通过集合和迭代器接口与两者进行交互

示例1

Iterator.cpp

template<typename T>
class Iterator
{
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const = 0;
    virtual T& current() = 0;
};

template<typename T>
class MyCollection{
    
public:
    
    Iterator<T> GetIterator(){
        //...
    }
    
};

template<typename T>
class CollectionIterator : public Iterator<T>{
    MyCollection<T> mc;
public:
    
    CollectionIterator(const MyCollection<T> & c): mc(c){ }
    
    void first() override {
        
    }
    void next() override {
        
    }
    bool isDone() const override{
        
    }
    T& current() override{
        
    }
};

void MyAlgorithm()
{
    MyCollection<int> mc;
    
    Iterator<int> iter= mc.GetIterator();
    
    for (iter.first(); !iter.isDone(); iter.next()){
        cout << iter.current() << endl;
    }
    
}

示例2

#include <iostream>
#include <string>
#include <vector>
using namespace std;

template <typename T, typename U>
class Iterator{
    public:
        typedef typename vector<T>::iterator iter_type;
        Iterator(U *p_data, bool reverse = false):m_p_data_(p_data){
            m_it_ = m_p_data_->m_data_.begin();
        }
        
        void First(){
            m_it_ = m_p_data_ -> m_data_.begin();
        }
        
        void Next(){
            m_it_++; 
        } 
        
        bool IsDone(){
            return(m_it_ == m_p_data_ -> m_data_.end());
        }
        
        iter_type Current(){
            return m_it_;
        }
        
    private:
        U *m_p_data_;
        iter_type m_it_;
}; 

template <class T>
class Container{
    friend class Iterator<T, Container>;
    public:
        void Add(T a){
            m_data_.push_back(a);
        }
        
        Iterator<T,Container> *CreateIterator(){
            return new Iterator<T, Container>(this);
        }
        
        private:
            vector<T> m_data_; 
};

class Data{
    public:
        Data(int a = 0): m_data_(a){}
        
        void set_data(int a){
            m_data_ = a;
        }
        
        int data(){
            return m_data_;
        }
        
        private:
            int m_data_;
};

void ClientCode(){
    cout<<"________________Iterator with int______________________________________"<<endl; 
    Container<int> cont;
    
    for(int i = 0 ; i < 10 ; i ++){
        cont.Add(i);
    }
    
    Iterator<int, Container<int>> *it = cont.CreateIterator();
    for(it->First(); !it->IsDone(); it->Next()){
        cout << *it->Current() << endl;
    }
    
    Container<Data> cont2;
    Data a(100),b(1000),c(10000);
    cont2.Add(a);
    cont2.Add(b);
    cont2.Add(c);
    
    cout<< "________________Iterator with custom Class______________________________"<<endl;
    Iterator<Data, Container<Data>> *it2 = cont2.CreateIterator();
    for(it2->First();!it2->IsDone();it2->Next()){
        cout << it2->Current()->data() << endl;
    }
}    

int main(){
    ClientCode();
    return 0;
}

________________Iterator with int______________________________________
0
1
2
3
4
5
6
7
8
9
________________Iterator with custom Class______________________________
100
1000
10000

 示例3

public interface Iterator {
    public boolean hasNext();
    public Object next();
}

public interface Container {
    public Iterator getIterator();
}

public class NameRepository implements Container{
    public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }
    
    private class NameIterator implements Iterator{
        int index; 
        
        @Override
        public boolean hasNext() {
            if(index < names.length) {
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(this.hasNext()) {
                return names[index++];
            }
            return null;
        }
    }
}

public class IteratorPatternDemo {
    public static void main(String[] args) {
    NameRepository namesRepository = new NameRepository();
    
    for(Iterator iter = namesRepository.getIterator();iter.hasNext();) {
        String name = (String)iter.next();
        System.out.println("Name : " + name);
        }
    }
}

Name : Robert
Name : John
Name : Julie
Name : Lora

参考

迭代器模式c++实现

https://blog.csdn.net/u012611878/article/details/78010435

CSDN：MachineChen