Eine kurze Einführung in das Iteratormuster in C++-Entwurfsmustern

Iteratormuster: Bietet eine Methode für den sequentiellen Zugriff auf jedes Element in einem Aggregatobjekt, ohne die interne Darstellung des Objekts offenzulegen. [DP]

Vier Rollen:

Abstrakte Iteratorklasse: Wird zum Definieren abstrakter Methoden verwendet, z. B. zum Abrufen des Startobjekts, zum Abrufen des nächsten Objekts, zur Beurteilung, ob das Ende erreicht ist, zum aktuellen Objekt, usw., einheitliche Schnittstelle.

ConcreteIterator Konkrete Iteratorklasse: Erbt Iterator und implementiert Methoden wie ein bestimmtes Startobjekt und ein nächstes Objekt.

Abstrakte Aggregationsklasse: Erstellen Sie einen Iterator

ConcreteAggregate konkrete Aggregationsklasse

Anwendbare Anlässe:

Wenn Sie unabhängig davon auf ein Aggregatobjekt zugreifen müssen Diese Was ist das Objekt, es muss nur durchlaufen werden.

Wenn Sie die Sammlung auf mehrere Arten durchlaufen müssen, z. B. von vorne nach hinten oder von hinten nach vorne.

Bietet eine einheitliche Struktur zum Durchlaufen verschiedener Aggregationsstrukturen, z. B. Start, Nächster, ob enden soll und welches Element sich aktuell befindet.

Testfall:

[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;
}

Implementierung des Iteratormusters:

[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);
}

Zusammenfassung: Das Iteratormuster trennt das Durchlaufverhalten von Sammlungsobjekten und abstrahiert eine Iteration der Handlerklasse ist dafür verantwortlich, sodass die interne Struktur der Sammlung nicht offengelegt wird und externer Code transparent auf die Daten innerhalb der Sammlung zugreifen kann.

Das Obige ist der Inhalt einer kurzen Einführung in das Iteratormuster in C++-Entwurfsmustern. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!