C++设计模式 迭代器模式

1. 理论基础

意图：
提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决：
不同的方式来遍历整个整合对象。

何时使用：
遍历一个聚合对象。

如何解决：
把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码：
定义接口：hasNext, next。

应用实例：
C++中的 iterator。

优点：
1、它支持以不同的方式遍历一个聚合对象。
2、迭代器简化了聚合类。
3、在同一个聚合上可以有多个遍历。
4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：
由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

使用场景：
1、访问一个聚合对象的内容而无须暴露它的内部表示。
2、需要为聚合对象提供多种遍历方式。
3、为遍历不同的聚合结构提供一个统一的接口。

注意事项：
迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

2. 逻辑代码

通过聚合类中items作为存储数组
要想遍历这个items就需要通过迭代器类进行遍历
核心代码是重载操作符[]来实现

template<class T>
class Iterator;

template<class T>
class ConcreteIterator;

template<class T>
class Aggregate;

template<class T>
class ConcreteAggregate;


// 聚集抽象类
template<class T>
class Aggregate{
public:
    // 创建一个迭代器
    virtual Iterator<T> *CreateIterator(){};
};

// 具体聚集类 
template<class T>
class ConcreteAggregate : public Aggregate<T>{
private:
    vector<T> items; // 声明一个泛型变量, 用于存放聚合对象
public:
    // 创建一个自己的迭代器
    Iterator<T> *CreateIterator(){
        return new ConcreteIterator<T>(this);
    }

    // 返回聚集总数
    int Size(){
        return items.size();
    }

    // [] 重载
    T &operator[] (int index){
        cout << "使用重载" << index << endl;
        return items[index];
    }

    void push_back(T val){
        items.push_back(val);
    }

    void print(){
        cout << "当前聚类里面的内容有: " << endl;
        for(auto & a : items){
            cout << a << " ";
        }cout<< "/n" << endl;
    }
};
// 迭代器模式
// 迭代器抽象类
template<class T> // l类似于Java中的object, 也就是所有类的祖宗
class Iterator{
public:
    // 用于定义得到开始, 下一个, 是否结尾, 当前对象的方法的统一接口
    virtual T First(){};
    virtual T Next(){};
    virtual bool IsDone(){};
    virtual T CurrentItem(){};
};
// 具体迭代器
template<class T>
class ConcreteIterator : public Iterator<T>{
private:    
    ConcreteAggregate<T> *aggregate = nullptr; // 定义了一个具体的聚集对象
    int current = 0;
public:
    // 初始化时 具体的聚集对象传入
    ConcreteIterator(ConcreteAggregate<T> *aggregate) : aggregate(aggregate){
        cout << "当前聚类中长度有: " << this->aggregate->Size() << endl;
    } 

    // 得到第一个聚集对象, 由于传过来的是指针, 需要通过(*指针)在通过[] 重载运算符访问iter里面对应的对象
    T First(){
        return (*aggregate)[0];
    }

    // 得到当前的
    T CurrentItem(){
        return (*aggregate)[current];
    }

    // 得到下一个
    T Next(){
        T ret = "";
        current++;
        if(current < aggregate->Size()){
            ret = (*aggregate)[current];
        }
        return ret;
    }

    bool IsDone(){
        return current >= aggregate->Size() ? true : false;
    }
};
void test(){
    ConcreteAggregate<string> *a = new ConcreteAggregate<string>(); // 10个乘客的公交车, 聚集对象
    a->push_back("大鸟");
    a->push_back("算法");
    a->push_back("放到");
    a->push_back("奇偶偶");
    a->print();
    Iterator<string> *i = new ConcreteIterator<string>(a); // 售票员出厂, 开始迭代所有人
    string item = i->First();
    cout << "first: " << item << endl;
    cout << "currentItem: " << i->CurrentItem() << endl;

    cout<< "----------------" << endl;
    while(!i->IsDone()){
        cout << i->CurrentItem() << endl;
        i->Next();
    }
    delete a; a = nullptr;
    delete i; i = nullptr;
}

输出

 前聚类里面的内容有: 
大鸟 算法 放到 奇偶偶 /n
当前聚类中长度有: 4
使用重载0
first: 大鸟
currentItem: 使用重载0
大鸟
----------------
使用重载0
大鸟
使用重载1
使用重载1
算法
使用重载2
使用重载2
放到
使用重载3
使用重载3
奇偶偶

3. 应用

3.1 vector迭代器 (有问题,等待高手解决)

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
class Container;
class NameRepository;
class Iterator;
class NameIterator;

class Container {
public:
    virtual Iterator *CreateIterator(){};
};


class NameRepository : public Container {
private:
   vector<string> names = {"Robert" , "John" ,"Julie" , "Lora"};
 
public:
    // 创建自己的迭代器
    Iterator *CreateIterator(){
        return new NameIterator(this);
        // return nullptr;
    };

    // [] 重载
    string &operator[] (int index){
        cout << "使用重载" << index << endl;
        return names[index];
    }

    int size(){
        return names.size();
    }
};


class Iterator {
public:
   virtual bool hasNext(){};
   virtual string next(){};
};

class NameIterator : public Iterator {
private:
    int index = 0;
    NameRepository *p = nullptr;
public:
    NameIterator(){}
    // 将聚类对象传入到这个迭代器中进行迭代
    NameIterator(NameRepository *nameStore) {
        this->p = nameStore;
        cout << "当前聚类中长度有: " << this->p->size() << endl;
    } 

    // 返回是否还有
    bool hasNext() {
        return index < p->size() ? true : false;
    }

    // 返回迭代器的下一个value
    string next() {
        if(this->hasNext()){
            return (*p)[index++];
        }
        return "";
    }     
};


int main(){
    NameRepository *repository = new NameRepository();

    NameIterator * iter = new NameIterator(repository); // 创建repository的迭代器
    while(iter->hasNext()){
        cout << iter->next() <<endl;
    }
    return 0;
}

error: invalid use of incomplete type ‘class NameIterator’
return new NameIterator(this);