C++设想形式浅识迭代器形式【C#.Net教程】,C++，设计模式，迭代器模式

迭代器形式：供应一中要领递次接见一个聚合对象中的各个元素，而又不暴露该对象的内部示意。【DP】

四个角色：

Iterator迭代器笼统类: 用于定义获得最先对象，获得下一个对象、推断是不是到末端、当前对象等笼统要领，一致接口。

ConcreteIterator详细迭代器类： 继续Iterator，完成详细最先对象、下一个对象等要领。

Aggregate群集笼统类： 建立迭代器

ConcreteAggregate详细群集类

实用场所：

当你须要接见一个群集对象，而且不论这些对象是什么，只须要遍历的时刻。

须要对群集有多种体式格局遍用时，如夙昔至后或从后至前。

为遍历差别的群集构造供应如最先、下一个、是不是完毕、当前哪一项等一致的构造。

测试用例：

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

迭代器形式完成：

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

总结：迭代器形式就是分离了鸠合对象的遍历行动，笼统出一个迭代器类来担任，如许既可以做到不暴露鸠合内部构造，又可以让外部代码透明地接见鸠合内部的数据。

以上就是C++设想形式浅识迭代器形式的内容，更多相关内容请关注ki4网（www.ki4.cn）！