设计模式之迭代器模式

最新推荐文章于 2024-07-12 23:09:31 发布
最新推荐文章于 2024-07-12 23:09:31 发布
阅读量581 收藏 10
点赞数 22
分类专栏： 设计模式 文章标签： 设计模式 迭代器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38492525/article/details/139532618
版权

迭代器模式（Iterator Pattern）是一种行为设计模式，它提供了一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式使得不同的聚合结构可以使用统一的接口来遍历其元素。

使用场景

  1. 遍历集合对象：
    当你需要遍历一个集合对象中的所有元素时，可以使用迭代器模式。

    示例：在一个列表、栈、队列等集合中，使用迭代器模式来遍历元素。

  2. 提供统一的遍历接口：
    当你希望不同的集合结构提供统一的遍历接口时，可以使用迭代器模式。

    示例：不同的容器类型（如数组和链表）可以使用相同的迭代器接口来遍历其元素。

  3. 隐藏集合的内部实现：
    当你希望隐藏集合的内部实现，只暴露一个遍历接口时，可以使用迭代器模式。

    示例：在一个图书馆管理系统中，用户可以遍历图书集合，但不需要知道图书集合的具体实现。

UML类图

+-------------------+       +-------------------+
|  Iterator         |       | Aggregate         |
+-------------------+       +-------------------+
| +first()          |       | +createIterator() |
| +next()           |       +-------------------+
| +isDone()         |               /|\
| +currentItem()    |                |
+-------------------+                |
          ^                          |
          |                          |
+-------------------+       +-------------------+
| ConcreteIterator  |       | ConcreteAggregate |
+-------------------+       +-------------------+
| -current: int     |       | -items: List      |
| +first()          |       | +createIterator() |
| +next()           |       +-------------------+
| +isDone()         |
| +currentItem()    |
+-------------------+

类图解释

  1. Iterator（迭代器接口）：

    • 职责：定义访问和遍历元素的接口方法。
    • 方法：
      • first()：将迭代器定位到第一个元素。
      • next()：将迭代器移动到下一个元素。
      • isDone()：检查是否遍历完所有元素。
      • currentItem()：返回当前元素。

  2. ConcreteIterator（具体迭代器）：

    • 职责：实现迭代器接口，维护当前遍历位置。
    • 属性：
      • current：当前元素的索引。
    • 方法：
      • 实现 Iterator 接口的所有方法，管理遍历的状态和行为。

  3. Aggregate（聚合接口）：

    • 职责：定义创建迭代器的接口方法。
    • 方法：
      • createIterator()：创建并返回一个迭代器对象。

  4. ConcreteAggregate（具体聚合）：

    • 职责：实现聚合接口，存储集合元素并返回具体的迭代器对象。
    • 属性：
      • items：存储集合元素的列表。
    • 方法：
      • 实现 Aggregate 接口的 createIterator 方法，返回一个具体的迭代器对象。

示例代码

假设我们有一个集合类，用于存储整数，并提供遍历这些整数的方法。我们用迭代器模式来实现这个场景。

#include <iostream>
#include <vector>
#include <memory>

// 迭代器接口
template <typename T>
class Iterator {
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const = 0;
    virtual T currentItem() const = 0;
    virtual ~Iterator() = default;
};

// 聚合接口
template <typename T>
class Aggregate {
public:
    virtual std::unique_ptr<Iterator<T>> createIterator() const = 0;
    virtual ~Aggregate() = default;
};

// 具体迭代器
template <typename T>
class ConcreteIterator : public Iterator<T> {
public:
    ConcreteIterator(const std::vector<T>& items)
        : items_(items), current_(0) {}

    void first() override {
        current_ = 0;
    }

    void next() override {
        if (!isDone()) {
            ++current_;
        }
    }

    bool isDone() const override {
        return current_ >= items_.size();
    }

    T currentItem() const override {
        if (!isDone()) {
            return items_[current_];
        }
        throw std::out_of_range("Iterator out of range");
    }

private:
    const std::vector<T>& items_;
    size_t current_;
};

// 具体聚合
template <typename T>
class ConcreteAggregate : public Aggregate<T> {
public:
    ConcreteAggregate(const std::initializer_list<T>& items)
        : items_(items) {}

    std::unique_ptr<Iterator<T>> createIterator() const override {
        return std::make_unique<ConcreteIterator<T>>(items_);
    }

private:
    std::vector<T> items_;
};

// 客户端代码
int main() {
    ConcreteAggregate<int> aggregate = {1, 2, 3, 4, 5};
    std::unique_ptr<Iterator<int>> iterator = aggregate.createIterator();

    for (iterator->first(); !iterator->isDone(); iterator->next()) {
        std::cout << iterator->currentItem() << " ";
    }

    std::cout << std::endl;
    return 0;
}

代码解读

  1. Iterator（迭代器接口）：

    • 职责：定义了访问和遍历集合元素的方法。
    • 方法：
      • first()：将迭代器定位到第一个元素。
      • next()：将迭代器移动到下一个元素。
      • isDone()：检查是否遍历完所有元素。
      • currentItem()：返回当前元素。

  2. ConcreteIterator（具体迭代器）：

    • 职责：实现 Iterator 接口，维护当前遍历位置。
    • 属性：
      • items_：存储集合元素的引用。
      • current_：当前元素的索引。
    • 方法：
      • 实现 Iterator 接口的所有方法，管理遍历的状态和行为。

  3. Aggregate（聚合接口）：

    • 职责：定义创建迭代器的接口方法。
    • 方法：
      • createIterator()：创建并返回一个迭代器对象。

  4. ConcreteAggregate（具体聚合）：

    • 职责：实现 Aggregate 接口，存储集合元素并返回具体的迭代器对象。
    • 属性：
      • items_：存储集合元素的列表。
    • 方法：
      • 实现 Aggregate 接口的 createIterator 方法，返回一个具体的迭代器对象。

优点

  1. 统一遍历接口：
    通过迭代器模式，不同的集合结构可以使用相同的接口来遍历其元素。

  2. 隐藏集合的内部实现：
    迭代器模式隐藏了集合的内部实现，只暴露了遍历元素的方法。

  3. 提高代码的灵活性：
    迭代器模式使得集合和遍历算法可以独立变化，提高了代码的灵活性和可维护性。

缺点

  1. 增加了类的数量：
    使用迭代器模式会增加额外的迭代器类和接口，增加了代码的复杂性。

  2. 可能影响性能：
    迭代器的实现需要维护遍历状态，可能会带来一定的性能开销。

使用场景总结

  1. 遍历集合对象：如列表、栈、队列等集合。
  2. 提供统一的遍历接口：如不同容器类型使用相同的迭代器接口。
  3. 隐藏集合的内部实现：如图书馆管理系统中的图书集合。

通过这个例子和解释，可以看到迭代器模式在提供统一的遍历接口、隐藏集合内部实现和提高代码灵活性方面的强大功能。

示例2

图书馆书架

假设我们有一个图书馆，其中有多种类型的书架，每个书架存放不同类别的书。我们需要一个迭代器来遍历这些书架上的书，并且让这个迭代器模式适应不同类型的书架。

具体代码示例

我们将使用两个不同类型的书架，一个用于存放小说，另一个用于存放科学书籍。每个书架都有自己的迭代器来遍历其中的书籍。

#include <iostream>
#include <vector>
#include <memory>
#include <string>

// 迭代器接口
template <typename T>
class Iterator {
public:
    virtual void first() = 0;
    virtual void next() = 0;
    virtual bool isDone() const = 0;
    virtual T currentItem() const = 0;
    virtual ~Iterator() = default;
};

// 聚合接口
template <typename T>
class Aggregate {
public:
    virtual std::unique_ptr<Iterator<T>> createIterator() const = 0;
    virtual ~Aggregate() = default;
};

// 小说书架迭代器
class NovelIterator : public Iterator<std::string> {
public:
    NovelIterator(const std::vector<std::string>& books)
        : books_(books), current_(0) {}

    void first() override {
        current_ = 0;
    }

    void next() override {
        if (!isDone()) {
            ++current_;
        }
    }

    bool isDone() const override {
        return current_ >= books_.size();
    }

    std::string currentItem() const override {
        if (!isDone()) {
            return books_[current_];
        }
        throw std::out_of_range("Iterator out of range");
    }

private:
    const std::vector<std::string>& books_;
    size_t current_;
};

// 科学书架迭代器
class ScienceIterator : public Iterator<std::string> {
public:
    ScienceIterator(const std::vector<std::string>& books)
        : books_(books), current_(0) {}

    void first() override {
        current_ = 0;
    }

    void next() override {
        if (!isDone()) {
            ++current_;
        }
    }

    bool isDone() const override {
        return current_ >= books_.size();
    }

    std::string currentItem() const override {
        if (!isDone()) {
            return books_[current_];
        }
        throw std::out_of_range("Iterator out of range");
    }

private:
    const std::vector<std::string>& books_;
    size_t current_;
};

// 小说书架
class NovelShelf : public Aggregate<std::string> {
public:
    NovelShelf(const std::initializer_list<std::string>& books)
        : books_(books) {}

    std::unique_ptr<Iterator<std::string>> createIterator() const override {
        return std::make_unique<NovelIterator>(books_);
    }

private:
    std::vector<std::string> books_;
};

// 科学书架
class ScienceShelf : public Aggregate<std::string> {
public:
    ScienceShelf(const std::initializer_list<std::string>& books)
        : books_(books) {}

    std::unique_ptr<Iterator<std::string>> createIterator() const override {
        return std::make_unique<ScienceIterator>(books_);
    }

private:
    std::vector<std::string> books_;
};

// 客户端代码
int main() {
    NovelShelf novelShelf = {"The Great Gatsby", "To Kill a Mockingbird", "1984"};
    ScienceShelf scienceShelf = {"A Brief History of Time", "The Selfish Gene", "Cosmos"};

    std::unique_ptr<Iterator<std::string>> novelIterator = novelShelf.createIterator();
    std::unique_ptr<Iterator<std::string>> scienceIterator = scienceShelf.createIterator();

    std::cout << "Novels:" << std::endl;
    for (novelIterator->first(); !novelIterator->isDone(); novelIterator->next()) {
        std::cout << novelIterator->currentItem() << std::endl;
    }

    std::cout << "\nScience Books:" << std::endl;
    for (scienceIterator->first(); !scienceIterator->isDone(); scienceIterator->next()) {
        std::cout << scienceIterator->currentItem() << std::endl;
    }

    return 0;
}

工作流程

  1. 创建具体集合对象：

    • 创建具体的集合对象，如 NovelShelf 和 ScienceShelf，并初始化其中的元素。

  2. 创建迭代器对象：

    • 调用具体集合对象的 createIterator 方法，创建并返回一个具体的迭代器对象。

  3. 遍历集合元素：

    • 使用迭代器对象的 first、next、isDone 和 currentItem 方法，遍历集合中的元素。

通过这个独特的例子，可以看到迭代器模式如何在不同类型的书架中应用，并且统一了遍历接口，使得客户端代码可以以相同的方式遍历不同的集合。

下面我来做一个总结吧！

总的来说，迭代器模式的核心就是提供一种统一的方式来遍历不同类型的集合。无论集合的内部实现是数组、链表、树还是其他数据结构，迭代器模式都可以提供一致的遍历接口，让客户端代码无需关心集合的具体实现细节。

关键点总结

  1. 统一遍历接口：
    迭代器模式为不同类型的集合提供了统一的遍历接口，使得客户端代码可以用相同的方式遍历不同的集合。

  2. 隐藏内部实现：
    迭代器模式隐藏了集合的内部实现细节，只暴露遍历所需的接口，减少了客户端代码对集合具体实现的依赖。

  3. 增加代码灵活性和可维护性：
    通过统一的遍历接口，迭代器模式提高了代码的灵活性和可维护性，使得集合和遍历算法可以独立变化。

示例中的体现

在我们的示例中，NovelShelf 和 ScienceShelf 分别表示不同类型的书架，每个书架都有自己的具体迭代器 NovelIterator 和 ScienceIterator。通过实现统一的 Iterator 接口，这些迭代器提供了一致的遍历方法（first, next, isDone, currentItem），使得客户端代码可以用相同的方式遍历这两种不同的书架。

适用场景

迭代器模式在以下场景中特别有用：

  1. 多种集合类型：
    当系统中存在多种不同类型的集合（如数组、链表、树等）时，迭代器模式可以提供一致的遍历接口，简化客户端代码。

  2. 需要隐藏集合实现：
    当需要隐藏集合的内部实现，只暴露遍历接口时，迭代器模式是一个很好的选择。

  3. 需要频繁遍历集合：
    当系统需要频繁遍历集合中的元素时，迭代器模式可以提高代码的灵活性和可维护性。

结论

迭代器模式提供了一种统一的方式来遍历不同类型的集合，使得客户端代码可以用一致的方式遍历这些集合，增强了代码的灵活性和可维护性。随着集合类型的增多，这种统一遍历的优势会更加明显。

希望这样的解释可以帮到你！！！

Grazve
关注
  • 22
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP设计模式之迭代器模式
01-20
迭代器模式实例： <?php class ConcreteIterator implements Iterator{ private $position = 0; private $arr; function __construct(array $arr){ $this->arr = $arr; } function rewind(){ $
C++设计模式之迭代器模式
K1_uestc的博客
01-23 1323
迭代器模式是⼀种行为设计模式，是⼀种使⽤频率⾮常⾼的设计模式，在各个语⾔中都有应用，其主要⽬的是提供⼀种统⼀的⽅式来访问⼀个聚合对象中的各个元素，而不需要暴露该对象的内部表示。通过迭代器，客户端可以顺序访问聚合对象的元素，而无需了解底层数据结构。
设计模式之迭代器模式(C++)
翟天保的博客
04-12 1万+
介绍设计模式之迭代器模式
23种设计模式之迭代器模式（Iterator Pattern）
热门推荐
小威的博客
05-27 2万+
本篇文章将23种设计模式中的迭代器模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
Java设计模式之迭代器模式
本人是个小小程序员，此博客一是为了激励自己学习，二是为了记录自己的学习历程，三是为了能够及时回顾相关知识。
07-15 652
了解迭代器模式的应用场景了解迭代器模式的优缺点迭代器模式（Iterator）提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。访问一个聚合对象的内容而无须暴露它的内部表示遍历任务交由迭代器完成，简化了聚合类它支持以不容方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历增加新的聚合类和迭代器类都很方便，无须修改原有代码封装性良好，为遍历不同的聚合结构提供一个统一的接口。...
JAVA设计模式之迭代器模式详解
励志成为一名优秀的全能型软件开发工程师。
02-12 1237
迭代器模式是我们学习一个设计时很少用到的、但编码实现时却经常使用到的行为型设计模式。在绝大多数编程语言中，迭代器已经成为一个基础的类库，直接用来遍历集合对象。在平时开发中，我们更多的是直接使用它，很少会从零去实现一个迭代器。迭代器模式(Iterator pattern)又叫游标（Cursor）模式，它的原始定义是：迭代器提供一种对容器对象中的各个元素进行访问的方法，而又不需要暴露该对象的内部细节。
C#设计模式之迭代器模式
BraveRunTo的博客
07-20 507
迭代器模式 文章目录迭代器模式模式分类模式产生的原因模式的灵感来源模式类图代码实现迭代器模式总结迭代器模式的优点：迭代器模式的缺点： 本篇博客将介绍迭代器模式，迭代器模式将一个聚合对象保存数据的职责，和它遍历数据的职责分离，在引入迭代器后，聚合对象只负责保存数据，而遍历数据交给迭代器来完成。迭代器模式的介绍将参考.NET中的迭代器来进行说明。 模式分类 行为型设计模式。 模式产生的原因 在软件开发中，为了可以更加方便的操作聚合对象，同时可以很灵活的为聚合对象增加不同的遍历方法，我们需要一个解决方案可以让我们
设计模式之迭代器模式（Iterator）的C++实现
hanxiaoyong_的博客
08-20 1275
迭代器模式（Iterator）的C++实现，泛型编程实现迭代器的C++实现。在软件开发过程中，操作的集合对象内部结构常常变化，在访问这些对象元素的同时，也要保证对象内部的封装性。迭代器模式提供了一种利用面向对象的遍历方法来遍历对象元素。迭代器模式通过抽象一个迭代器类，不同的对象继承自迭代器类，外部通过统一接口访问元素。面向对象实现的迭代器模式是在程序运行时，通过虚函数去操作对象元素；相比于C++中的泛型编程实现迭代器的运行性能较低（泛型编程是在编译时已确定访问的元素），所以建议使用泛型编程实现迭代器。
javascript设计模式之迭代器模式
10-15
迭代器模式是软件设计模式中的一种，主要用于顺序访问聚合对象的元素，而又不暴露其底层表示。在JavaScript中，迭代器模式允许我们遍历任何可迭代对象，如数组、对象或者实现了迭代器接口的自定义数据结构。这种模式...
常用设计模式
u010992421的专栏
07-12 938
设计模式是在软件开发中经过验证的、用于解决常见问题的最佳实践。它们可以帮助开发者设计出更加灵活、可维护和可扩展的软件系统。这些设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式。
GPT带我学-设计模式13-策略模式
qq_37398465的博客
07-09 495
策略模式。
Java学习笔记整理: 关于设计模式解析和设计原则 2024/7/10；
gzx233的博客
07-10 601
Java设计模式设计原则
JavaScript设计模式 -- 代理模式
m0_73280507的博客
07-10 975
@FilePath: \设计模式\代理模式.md* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE。
设计模式探索：适配器模式
搬砖的小熊猫的博客
07-09 1166
将一个类的接口转换为客户期望的另一个接口，适配器可以让不兼容的两个类一起协同工作。适配器模式的主要作用是把原本不兼容的接口，通过适配修改做到统一，使得用户方便使用。比如，万能充电器和多接口数据线都是为了适配各种不同的接口。为什么要转换接口？原接口和目标接口都已经存在，不易修改接口代码。抽象接口希望复用已有组件的逻辑。优点：解耦合: 适配器模式允许两个没有直接关联的类协同工作，降低了它们之间的耦合度。提高复用性: 通过适配器，可以重用现有的类，而不需要修改它们的代码。统一接口。
java设计模式之:策略模式+工厂模式整合案例实战(一)
最新发布
royal1235的博客
07-12 297
然后通过策略工厂来获取具体的策略类：(由于只有三个策略类，所以通过注入的方式对channel进行判断)案例1：项目中对系统中的客户和销售进行事件通知(短信、邮件、钉钉)到此该版本的策略模式+工厂模式就结束了，欢迎点评和指出不足之处。首先要有通知的策略接口，接口里面要有一个方法就是通知的方法。有了接口那必然有实现类，三个实现类短信、邮件、钉钉。该案例是针对策略类比较少的情况。下一篇会讲解策略类比较多的案例。本文介绍项目中常用的。
Java面试题系列 - 第9天
一杯梅子酱的博客
07-11 884
它们是前辈开发者在实践中总结出来的经验教训，通过模式化的设计，可以减少代码的复杂性，提高代码的复用性和可维护性。设计模式的重要性在于，它们提供了一种通用的语言，使得开发者能够更有效地沟通和协作。：观察者模式 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。：设计模式是软件工程中解决问题的常见方案，它们提供了经过验证的模板，帮助开发者解决在软件设计过程中遇到的特定问题。设计模式的学习是一个持续的过程，随着经验的积累，开发者会更加熟练地应用这些模式来解决复杂的设计问题。
Java中的设计模式：工厂模式
技术研究中心
07-10 258
本文介绍了工厂模式及其在Java中的三种主要形式：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其独特的应用场景和实现方式，可以帮助开发人员更好地管理对象的创建过程，提高代码的可扩展性和可维护性。简单工厂模式是工厂模式的最简单形式，它通过一个共同的接口或父类来创建对象，但客户端不需要知道具体实现类。抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！
Java设计模式课件迭代器模式.pptx
11-16
"Java设计模式课件迭代器模式.pptx" 迭代器模式是一种重要的设计模式，属于对象行为型模式，也被称为游标模式。它提供了一种方式，使得客户端可以顺序访问聚合对象（如集合）中的各个元素，而无需暴露这些对象的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值