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++设计模式浅识迭代器模式的内容，更多相关内容请关注PHP中文网（www.php.cn）！