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

待我称王封你为后i 2022-08-28 07:42 17阅读 0赞

### 文章目录 ###

*  1. 理论基础
 *  2. 逻辑代码
 *  3. 应用
 *   *  3.1 vector迭代器 (有问题,等待高手解决)

# 1. 理论基础 #

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

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

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

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

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

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

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

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

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

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

# 2. 逻辑代码 #

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16]  
通过聚合类中`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);

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/ad99b14494d74a51b27f92120dd6cc3c.png