设计模式-行为型模式-迭代器模式

工程源码：

C++设计模式-行为型模式-迭代器模式https://download.csdn.net/download/qq_40788199/85774530码云：

C++设计模式-行为型模式-迭代器模式https://gitee.com/gongguixing/c-design-mode.git

1、模式的定义与特点

迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式，其主要优点如下。

1. 访问一个聚合对象的内容而无须暴露它的内部表示。
2. 遍历任务交由迭代器完成，这简化了聚合类。
3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

其主要缺点是：增加了类的个数，这在一定程度上增加了系统的复杂性。
在日常开发中，我们几乎不会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器，否则，开源框架提供的 API 完全够用。

2、模式的结构与实现

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。现在我们来分析其基本结构与实现方法。

1. 模式的结构

迭代器模式主要包含以下角色。

1. 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2. 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3. 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
4. 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

其结构图如图 1 所示。

3、代码实现 

3.1、对象结构体定义

#ifndef DEFINE_H
#define DEFINE_H

#include <string>
using namespace std;

struct Object
{
    string name;
    Object(const string &n) : name(n) {}
};

#endif // DEFINE_H

3.2、抽象聚合（Aggregate）角色

#ifndef IAGGREGATE_H
#define IAGGREGATE_H

#include "define.h"

class Iterator;

// 抽象聚合（Aggregate）角色
// 定义存储、添加、删除聚合对象以及创建迭代器对象的接口。

class IAggregate
{
public:
    virtual ~IAggregate() {}

    // 添加对象
    virtual void add(const Object &obj) = 0;

    // 删除对象
    virtual void remove(const Object &obj) = 0;

    // 迭获取代器
    virtual Iterator * getIterator()  = 0;
};

#endif // IAGGREGATE_H

3.3、具体聚合（ConcreteAggregate）角色 

#ifndef CONCRETEAGGREGATE_H
#define CONCRETEAGGREGATE_H

#include "iaggregate.h"
#include <vector>

// 具体聚合（ConcreteAggregate）角色
// 实现抽象聚合类，返回一个具体迭代器的实例。

class ConcreteAggregate : public IAggregate
{
public:
    ConcreteAggregate();
    ~ ConcreteAggregate();

    // 添加对象
    void add(const Object &obj) override;

    // 删除对象
    void remove(const Object &obj) override;

    // 获取迭代器
    Iterator * getIterator()  override;

private:
    vector<Object> mObjects;
    Iterator *mpIt;
};

#endif // CONCRETEAGGREGATE_H

#include "concreteaggregate.h"
#include <algorithm>
#include <iostream>
#include "concreteiterator.h"

ConcreteAggregate::ConcreteAggregate()
{
    mObjects.clear();
    mpIt = new ConcreteIterator(&mObjects);
}

ConcreteAggregate::~ConcreteAggregate()
{
    delete mpIt;
}

void ConcreteAggregate::add(const Object &obj)
{
    mObjects.push_back(obj);
}

void ConcreteAggregate::remove(const Object &obj)
{
    size_t size = mObjects.size();
    // 匿名函数，判断属性name是否已经存在
    auto fun = [obj](Object o)->bool{return o.name == obj.name;};
    // 移动赋值
    auto it = std::remove_if(mObjects.begin(), mObjects.end(), fun);
    // 删除
    mObjects.erase(it, mObjects.end());

    std::cout << "remove Object: " << obj.name << "  ";
    std::cout << (size == mObjects.size() ? "failure" : "success ") << std::endl;
}

Iterator *ConcreteAggregate::getIterator()
{
    return mpIt;
}

 3.4、抽象迭代器（Iterator）角色：

#ifndef ITERATOR_H
#define ITERATOR_H

#include "define.h"

// 抽象迭代器（Iterator）角色
// 定义访问和遍历聚合元素的接口，
// 通常包含 hasNext()、first()、next() 等方法。

class Iterator
{
public:
    virtual ~Iterator() {}

    // 获取第一个对象
    virtual Object * first() = 0;

    // 获取最后一个对象
    virtual Object * last() = 0;

    // 获取下一个对象
    virtual Object * next() = 0;

    // 是否存在下一个对象
    virtual bool hasNext() = 0;
};

#endif // ITERATOR_H

3.5、具体迭代器（Concretelterator）角色 

#ifndef CONCRETEITERATOR_H
#define CONCRETEITERATOR_H

#include "iterator.h"
#include <vector>

// 具体迭代器（Concretelterator）角色
// 实现抽象迭代器接口中所定义的方法，
// 完成对聚合对象的遍历，记录遍历的当前位置。

class ConcreteIterator : public Iterator
{
public:
    ConcreteIterator(vector<Object> *pObjects);

    // 获取第一个对象
    Object * first() override;

    // 获取最后一个对象
    Object * last() override;

    // 获取下一个对象
    Object * next() override;

    // 是否存在下一个对象
    bool hasNext() override;

private:
    vector<Object> *mpObjects;
    int index = 0;
};

#endif // CONCRETEITERATOR_H

#include "concreteiterator.h"

ConcreteIterator::ConcreteIterator(vector<Object> *pObjects)
{
    mpObjects = pObjects;
    index = -1;
}

Object *ConcreteIterator::first()
{
    if (!mpObjects)
    {
        return nullptr;
    }

    if (mpObjects->empty())
    {
        return nullptr;
    }

    index = 0;
    return &(mpObjects->at(index));
}

Object *ConcreteIterator::last()
{
    if (!mpObjects)
    {
        return nullptr;
    }

    if (mpObjects->empty())
    {
        return nullptr;
    }

    index = mpObjects->size() - 1;
    return &(mpObjects->at(index));
}

Object *ConcreteIterator::next()
{
    if (!mpObjects)
    {
        return nullptr;
    }

    Object * p = nullptr;

    // 如果存在下一个对象，则取出来
    if (hasNext())
    {
        p = &(mpObjects->at(++index));
    }

    return p;
}

bool ConcreteIterator::hasNext()
{
    return index < (int)(mpObjects->size() - 1) ? true : false;
}

 3.6、调用示例

#include <iostream>
#include "concreteaggregate.h"
#include "iterator.h"

int main()
{
    // 迭代器（Iterator）模式的定义：
    // 提供一个对象来顺序访问聚合对象中的一系列数据，
    // 而不暴露聚合对象的内部表示。

    // 实例化聚合角色
    IAggregate * pAg = new ConcreteAggregate();
    // 添加角色
    pAg->add(Object("Sun Yat-sen University"));
    pAg->add(Object("South China University of Technology"));
    pAg->add(Object("Nanjing University"));

    std::cout << "The contents of the aggregation are:" << std::endl;

    // 获取迭代器
    Iterator *it = pAg->getIterator();

    // 遍历迭代器
    while (it->hasNext())
    {
        Object * obj = it->next();
        std::cout << obj->name << std::endl;
    }

    std::cout << "--------------------------------------" << std::endl;

    // 访问迭代器首
    Object *fObj = it->first();
    std::cout << "first Object: " << fObj->name << std::endl;

    // 访问迭代器尾
    Object *lObj = it->last();
    std::cout << "last Object: " << lObj->name << std::endl;

    std::cout << "--------------------------------------" << std::endl;

    // 删除对象
    pAg->remove(Object("Sun Yat-sen University"));
    pAg->remove(Object("Sun Yat-sen University"));

    delete pAg;

    return 0;
}

 

 模式的应用场景

前面介绍了关于迭代器模式的结构与特点，下面介绍其应用场景，迭代器模式通常在以下几种情况使用。

1. 当需要为聚合对象提供多种遍历方式时。
2. 当需要为遍历不同的聚合结构提供一个统一的接口时。
3. 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

由于聚合与迭代器的关系非常密切，所以大多数语言在实现聚合类时都提供了迭代器类，因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。