设计模式学习笔记（C++实现）（十七）--迭代器模式

1.迭代器模式简介

• 英文名称
  Iterator
• 主要目的
  提供一种方法顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示。
• 使用场景
  1.访问一个聚合对象的内容，而无需暴露其内部表示的时候；
  2.支持对聚合对象的多种遍历；
  3.为遍历不同的聚合结构提供一个统一的接口。

2.迭代器模式代码示例

• 测试平台
  1.开发语言：C++
  2.开发工具：VS2015
  3.操作系统：Win7 X64

• 代码说明
  1.Iterator–抽象迭代器类，定义迭代器的基本接口；
  2.ConcreteIterator–具体迭代器类，在本例中用于表示员工名单；
  3.Aggregate–抽象聚集类，定义聚集类的基本接口；
  3.ConcreteAggregate–具体聚集类，实现聚集类的基本功能。

  注意：
  1.本例用迭代器模式来遍历公司员工名单；
  2.迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责。

• 具体代码

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//抽象迭代器类，定义迭代器的基本接口
class Iterator
{
public:
    //函数功能：构造函数
    //参数：    无
    //返回值：  无
    Iterator() {};

    //函数功能：析构函数
    //参数：    无
    //返回值：  无
    virtual ~Iterator() {};

    //函数功能：返回第一个元素
    //参数：    无
    //返回值：  string                    -- 元素值
    virtual string First() = 0;

    //函数功能：获取下一个元素
    //参数：    无
    //返回值：  string                    -- 元素值
    virtual string Next() = 0;

    //函数功能：获取当前元素
    //参数：    无
    //返回值：  string                    -- 元素值
    virtual string GetCurElement() = 0;

    //函数功能：是否移动到聚集类末尾
    //参数：    无
    //返回值：  bool                     -- 已移动到末尾，则返回true；否则返回false
    virtual bool IsEnd() = 0;
};

//抽象聚集类
class Aggregate
{
public:
    //函数功能：生成迭代器
    //参数：    无
    //返回值：  Iterator*                     -- 生成迭代器指针
    virtual Iterator* CreateIterator() = 0;

    //函数功能：获取元素总数
    //参数：    无
    //返回值：  int                          -- 聚集对象中的元素总数
    virtual int Size() = 0;

    //函数功能：向聚集类末尾增加一个元素
    //参数：    const string element[IN]     -- 要插入的元素值
    //返回值：  无
    virtual void Push_back(const string element) = 0;

    //函数功能：从聚集类中获取指定位置的元素
    //参数：    const int index[IN]          -- 获取的元素值
    //返回值：  string
    virtual string GetElemnt(const int index) = 0;
};

//具体迭代器类，在本例中用于表示员工名单
class ConcreteIterator : public Iterator
{
public:
    //函数功能：构造函数
    //参数：    Aggregate* pAggregate[IN]          -- 迭代器对应的聚集类指针
    //返回值：  无
    ConcreteIterator(Aggregate* pAggregate) :m_curIndex(0), Iterator()
    {
        m_Aggregate = pAggregate;
    }

    //函数功能：返回第一个元素
    //参数：    无
    //返回值：  string                    -- 元素值
    string First()
    {
        return m_Aggregate->GetElemnt(0);
    }

    //函数功能：获取下一个元素
    //参数：    无
    //返回值：  string                    -- 元素值
    string Next()
    {
        string strRet;
        m_curIndex++;
        if (m_curIndex < m_Aggregate->Size())
        {
            strRet = m_Aggregate->GetElemnt(m_curIndex);
        }
        return strRet;
    }

    //函数功能：获取当前元素
    //参数：    无
    //返回值：  string                    -- 元素值
    string GetCurElement()
    {
        string strRet= m_Aggregate->GetElemnt(m_curIndex);
        return strRet;
    }

    //函数功能：是否移动到聚集类末尾
    //参数：    无
    //返回值：  bool                     -- 已移动到末尾，则返回true；否则返回false
    bool IsEnd()
    {
        if (m_curIndex >= this->m_Aggregate->Size())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
private:
    Aggregate* m_Aggregate;                     //元素序列
    int m_curIndex;                             //当前元素序号
};

//具体聚集类，实现聚集类的基本功能
class ConcreteAggregate : public Aggregate
{
public:
    //函数功能：构造函数
    //参数：    无
    //返回值：  无
    ConcreteAggregate() :m_pIterator(NULL)
    {
    }

    //函数功能：析构函数
    //参数：    无
    //返回值：  无
    ~ConcreteAggregate()
    {
        if (this->m_pIterator!=NULL)
        {
            delete this->m_pIterator;
            this->m_pIterator = NULL;
        }
    }

    //函数功能：生成迭代器
    //参数：    无
    //返回值：  Iterator*                     -- 生成迭代器指针
    Iterator* CreateIterator()
    {
        if (NULL == this->m_pIterator)
        {
            this->m_pIterator = new ConcreteIterator(this);
        }
        return this->m_pIterator;
    }

    //函数功能：获取元素总数
    //参数：    无
    //返回值：  int                          -- 聚集对象中的元素总数
    int Size()
    {
        int iRet = this->m_itemsVector.size();
        return iRet;
    }

    //函数功能：向聚集类末尾增加一个元素
    //参数：    const string element[IN]     -- 要插入的元素值
    //返回值：  无
    void Push_back(const string element)
    {
        this->m_itemsVector.push_back(element);
    }

    //函数功能：从聚集类中获取指定位置的元素
    //参数：    const int index[IN]          -- 获取的元素值
    //返回值：  string
    string GetElemnt(const int index)
    {
        string strRet="";
        if (index < this->Size())
        {
            strRet = m_itemsVector[index];
        }
        return strRet;
    }
private:
    vector<string> m_itemsVector;                     //元素序列
    Iterator* m_pIterator;                            //迭代器指针
};
int main()
{
    Aggregate* pNameList = new ConcreteAggregate();
    if (NULL != pNameList)
    {
        //插入员工姓名
        pNameList->Push_back("ZhangSan");
        pNameList->Push_back("LiSi");
        pNameList->Push_back("WangWu");
        pNameList->Push_back("ZhaoLiu");

        //显示员工名单
        Iterator* pIterator = pNameList->CreateIterator();
        cout << "本公司员工名单如下：" << endl;
        if (NULL != pIterator)
        {
            string strItem = pIterator->First();
            while (!pIterator->IsEnd())
            {
                cout << pIterator->GetCurElement().c_str() << endl;
                pIterator->Next();
            }

            delete pIterator;
            pIterator = NULL;
        }

        delete pNameList;
        pNameList = NULL;
    }

    getchar();
    return 0;
}

• 输出结果
  

栏目导航
上一篇：设计模式学习笔记（C++实现）（十六）–解释器模式
下一篇：设计模式学习笔记（C++实现）（十八）–中介者模式

参考文献：
1.《设计模式：可复用面向对象软件的基础》