Une brève introduction au modèle d'itérateur dans les modèles de conception C

Modèle d'itérateur : fournit une méthode pour accéder séquentiellement à chaque élément d'un objet agrégé sans exposer la représentation interne de l'objet. [DP]

Quatre rôles :

Classe abstraite Iterator : utilisée pour définir des méthodes abstraites telles que obtenir l'objet de début, obtenir l'objet suivant, juger si la fin est atteinte, l'objet actuel, etc., interface unifiée.

ConcreteIterator Classe d'itérateur concret : hérite de l'itérateur et implémente des méthodes telles qu'un objet de départ spécifique et un objet suivant.

Classe abstraite d'agrégation d'agrégats : créer un itérateur

Classe d'agrégation concrète ConcreteAggregate

Occasions applicables :

Lorsque vous devez accéder à un objet d'agrégation, quel que soit le ceux-ci Ce qu'est l'objet, il suffit de le parcourir.

Lorsque vous devez parcourir la collection de plusieurs manières, par exemple d'avant en arrière ou d'arrière en avant.

Fournit une structure unifiée pour parcourir différentes structures d'agrégation, telles que début, suivant, fin ou non et quel élément se trouve actuellement.

Cas de test :

[code]int main(){
    ConcreteAggregate pa;
    pa.Add("BigBird");
    pa.Add("Pickles");
    pa.Add("Luggage");
    pa.Add("Foreigners");
    pa.Add("InnerStaff");
    pa.Add("Thief");

    ConcreteIterator Itr(pa);

    string temp = Itr.First();
    while (!Itr.IsDone())
    {
        std::cout << Itr.currentItem() << ", ticket, Please\n";
        Itr.Next();
    }

    return 0;
}

Implémentation du modèle d'itérateur :

[code]//迭代器模式
#include <iostream>
#include <deque>
#include <string>
using std::string;
using std::deque;

//MyIterator迭代器抽象类
class MyIterator{
public:
    MyIterator(){}
    //得到开始对象
    virtual string First() = 0;
    //得到下一个对象
    virtual string  Next() = 0;
    //判断是否到结尾
    virtual bool IsDone() = 0;
    //当前对象
    virtual string currentItem() = 0;   
};

//抽象聚集类
class Aggregate{
public:
    Aggregate(){}
    //创建迭代器
    virtual MyIterator* createIterator() = 0;
private:
    friend class MyIterator;
};
//具体聚集类
class ConcreteAggregate: public Aggregate{
public:
    MyIterator* createIterator();
    int Count();
    void Add(string st);
    string This(int index);
private:
    friend class ConcreteIterator;
    //乘客队列
    deque<string> passengers;
};

//具体的迭代器类
class ConcreteIterator: public MyIterator{
public:
    ConcreteIterator(ConcreteAggregate);
    string First();
    string Next();
    bool IsDone();
    string currentItem();
private:
    //以具体的聚集类为友元类
    friend class ConcreteAggregate;
    ConcreteAggregate aggregate;
    int current = 0;  
};

//方法实现
//具体迭代器类
ConcreteIterator::ConcreteIterator(ConcreteAggregate cAgg): aggregate(cAgg), current(cAgg.passengers.size() - 1){
}

string ConcreteIterator::First(){
    return  aggregate.This(0); 
}

string ConcreteIterator::Next(){
    string temp;
    --current;
    if(current >= 0)
        temp = aggregate.This(current);
    return temp;
}

string ConcreteIterator::currentItem(){
    return aggregate.This(current);
}

bool ConcreteIterator::IsDone(){
    return current >= 0 ? false : true;
}

//方法实现
//具体聚集类
MyIterator* ConcreteAggregate::createIterator(){
    return (new ConcreteIterator(*this));
}
int ConcreteAggregate::Count(){
    return passengers.size();
}
void ConcreteAggregate::Add(string st){
    passengers.push_back(st);
}
string ConcreteAggregate::This(int index){
    return passengers.at(index);
}

Résumé : Le modèle d'itérateur sépare le comportement de parcours des objets de collection et résume une itération. La classe de gestionnaire en est responsable, afin que la structure interne de la collection ne soit pas exposée et que le code externe puisse accéder de manière transparente aux données à l'intérieur de la collection.

Ce qui précède est une brève introduction au modèle d'itérateur dans les modèles de conception C. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !