迭代器模式与几个经典的C++实现

原创 于 2025-08-23 21:29:19 发布 · 301 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#迭代器模式 #c++

迭代器模式详解

1. 定义与意图

迭代器模式（Iterator Pattern） 是一种行为设计模式，它提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

主要意图：

  • 为不同的聚合结构提供统一的遍历接口。

  • 将遍历数据的职责与聚合对象本身分离，简化聚合接口。

  • 支持以不同方式遍历同一个聚合（如前序、中序、后序遍历二叉树）。

2. 模式结构

迭代器模式包含以下几个角色：

  1. Iterator（迭代器接口）：定义访问和遍历元素的接口。

  2. ConcreteIterator（具体迭代器）：实现迭代器接口，跟踪遍历的当前位置。

  3. Aggregate（聚合接口）：定义创建相应迭代器对象的接口。

  4. ConcreteAggregate（具体聚合）：实现创建相应迭代器的接口，返回具体迭代器的实例。

3. 适用场景

  • 需要访问聚合对象的内容而不暴露其内部表示

  • 支持对聚合对象的多种遍历方式

  • 为遍历不同的聚合结构提供统一的接口

4. 优点

  • 单一职责原则：将遍历算法与聚合对象分离

  • 开闭原则：可以引入新的迭代器而不修改现有代码

  • 可以并行遍历同一聚合，因为每个迭代器都有自己的状态

  • 可以暂停遍历并在需要时继续

5. 缺点

  • 对于简单的集合可能过于复杂

  • 某些情况下，使用专门的遍历方法可能比迭代器更高效

C++ 实现例子

例子1：自定义数组容器的迭代器

#include <iostream>
#include <stdexcept>

template <typename T, size_t SIZE>
class Array {
private:
    T data[SIZE];
    
public:
    // 迭代器类
    class Iterator {
    private:
        T* ptr;
        
    public:
        explicit Iterator(T* p) : ptr(p) {}
        
        // 前置++
        Iterator& operator++() {
            ++ptr;
            return *this;
        }
        
        // 后置++
        Iterator operator++(int) {
            Iterator temp = *this;
            ++ptr;
            return temp;
        }
        
        T& operator*() const {
            return *ptr;
        }
        
        T* operator->() const {
            return ptr;
        }
        
        bool operator==(const Iterator& other) const {
            return ptr == other.ptr;
        }
        
        bool operator!=(const Iterator& other) const {
            return !(*this == other);
        }
    };
    
    // const迭代器类
    class ConstIterator {
    private:
        const T* ptr;
        
    public:
        explicit ConstIterator(const T* p) : ptr(p) {}
        
        ConstIterator& operator++() {
            ++ptr;
            return *this;
        }
        
        ConstIterator operator++(int) {
            ConstIterator temp = *this;
            ++ptr;
            return temp;
        }
        
        const T& operator*() const {
            return *ptr;
        }
        
        const T* operator->() const {
            return ptr;
        }
        
        bool operator==(const ConstIterator& other) const {
            return ptr == other.ptr;
        }
        
        bool operator!=(const ConstIterator& other) const {
            return !(*this == other);
        }
    };
    
    // 获取开始迭代器
    Iterator begin() {
        return Iterator(data);
    }
    
    Iterator end() {
        return Iterator(data + SIZE);
    }
    
    ConstIterator begin() const {
        return ConstIterator(data);
    }
    
    ConstIterator end() const {
        return ConstIterator(data + SIZE);
    }
    
    ConstIterator cbegin() const {
        return ConstIterator(data);
    }
    
    ConstIterator cend() const {
        return ConstIterator(data + SIZE);
    }
    
    T& operator[](size_t index) {
        if (index >= SIZE) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }
    
    const T& operator[](size_t index) const {
        if (index >= SIZE) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }
    
    size_t size() const {
        return SIZE;
    }
};

// 使用示例
int main() {
    Array<int, 5> arr = {1, 2, 3, 4, 5};
    
    // 使用迭代器遍历
    std::cout << "Using iterator: ";
    for (auto it = arr.begin(); it != arr.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    // 使用范围for循环（基于迭代器）
    std::cout << "Using range-based for: ";
    for (const auto& item : arr) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

例子2：二叉树的中序遍历迭代器

#include <iostream>
#include <stack>
#include <memory>

template <typename T>
struct TreeNode {
    T value;
    std::shared_ptr<TreeNode> left;
    std::shared_ptr<TreeNode> right;
    
    TreeNode(T val) : value(val), left(nullptr), right(nullptr) {}
};

template <typename T>
class BinaryTree {
private:
    std::shared_ptr<TreeNode<T>> root;
    
public:
    BinaryTree() : root(nullptr) {}
    
    void setRoot(std::shared_ptr<TreeNode<T>> node) {
        root = node;
    }
    
    // 中序遍历迭代器
    class InOrderIterator {
    private:
        std::stack<std::shared_ptr<TreeNode<T>>> stack;
        std::shared_ptr<TreeNode<T>> current;
        
        void pushLeft(std::shared_ptr<TreeNode<T>> node) {
            while (node) {
                stack.push(node);
                node = node->left;
            }
        }
        
    public:
        explicit InOrderIterator(std::shared_ptr<TreeNode<T>> root) {
            current = nullptr;
            pushLeft(root);
            if (!stack.empty()) {
                current = stack.top();
                stack.pop();
            }
        }
        
        T& operator*() const {
            return current->value;
        }
        
        InOrderIterator& operator++() {
            if (current->right) {
                pushLeft(current->right);
            }
            
            if (stack.empty()) {
                current = nullptr;
            } else {
                current = stack.top();
                stack.pop();
            }
            
            return *this;
        }
        
        bool operator!=(const InOrderIterator& other) const {
            return current != other.current;
        }
        
        bool hasNext() const {
            return current != nullptr;
        }
    };
    
    InOrderIterator begin() {
        return InOrderIterator(root);
    }
    
    InOrderIterator end() {
        return InOrderIterator(nullptr);
    }
};

// 使用示例
int main() {
    // 创建二叉树: 
    //       1
    //      / \
    //     2   3
    //    / \
    //   4   5
    
    auto root = std::make_shared<TreeNode<int>>(1);
    root->left = std::make_shared<TreeNode<int>>(2);
    root->right = std::make_shared<TreeNode<int>>(3);
    root->left->left = std::make_shared<TreeNode<int>>(4);
    root->left->right = std::make_shared<TreeNode<int>>(5);
    
    BinaryTree<int> tree;
    tree.setRoot(root);
    
    std::cout << "In-order traversal: ";
    for (auto it = tree.begin(); it.hasNext(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

例子3：STL风格的迭代器适配器

#include <iostream>
#include <vector>
#include <iterator>

// 过滤迭代器：只返回满足条件的元素
template <typename Iterator, typename Predicate>
class FilterIterator {
private:
    Iterator current;
    Iterator end;
    Predicate predicate;
    
    void advanceToNextValid() {
        while (current != end && !predicate(*current)) {
            ++current;
        }
    }
    
public:
    FilterIterator(Iterator begin, Iterator end, Predicate pred)
        : current(begin), end(end), predicate(pred) {
        advanceToNextValid();
    }
    
    FilterIterator& operator++() {
        if (current != end) {
            ++current;
            advanceToNextValid();
        }
        return *this;
    }
    
    typename std::iterator_traits<Iterator>::value_type operator*() const {
        return *current;
    }
    
    bool operator!=(const FilterIterator& other) const {
        return current != other.current;
    }
    
    bool operator==(const FilterIterator& other) const {
        return current == other.current;
    }
};

// 辅助函数创建过滤迭代器
template <typename Iterator, typename Predicate>
FilterIterator<Iterator, Predicate> make_filter_iterator(
    Iterator begin, Iterator end, Predicate pred) {
    return FilterIterator<Iterator, Predicate>(begin, end, pred);
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // 定义谓词：只返回偶数
    auto isEven = [](int n) { return n % 2 == 0; };
    
    std::cout << "Even numbers: ";
    auto begin = make_filter_iterator(numbers.begin(), numbers.end(), isEven);
    auto end = make_filter_iterator(numbers.end(), numbers.end(), isEven);
    
    for (auto it = begin; it != end; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

例子4：支持多种遍历方式的集合

#include <iostream>
#include <vector>
#include <algorithm>

template <typename T>
class CustomCollection {
private:
    std::vector<T> data;
    
public:
    void add(const T& item) {
        data.push_back(item);
    }
    
    // 前向迭代器
    class ForwardIterator {
    private:
        typename std::vector<T>::iterator it;
        
    public:
        explicit ForwardIterator(typename std::vector<T>::iterator iter) : it(iter) {}
        
        ForwardIterator& operator++() {
            ++it;
            return *this;
        }
        
        T& operator*() const {
            return *it;
        }
        
        bool operator!=(const ForwardIterator& other) const {
            return it != other.it;
        }
    };
    
    // 反向迭代器
    class ReverseIterator {
    private:
        typename std::vector<T>::reverse_iterator it;
        
    public:
        explicit ReverseIterator(typename std::vector<T>::reverse_iterator iter) : it(iter) {}
        
        ReverseIterator& operator++() {
            ++it;
            return *this;
        }
        
        T& operator*() const {
            return *it;
        }
        
        bool operator!=(const ReverseIterator& other) const {
            return it != other.it;
        }
    };
    
    ForwardIterator begin() {
        return ForwardIterator(data.begin());
    }
    
    ForwardIterator end() {
        return ForwardIterator(data.end());
    }
    
    ReverseIterator rbegin() {
        return ReverseIterator(data.rbegin());
    }
    
    ReverseIterator rend() {
        return ReverseIterator(data.rend());
    }
};

int main() {
    CustomCollection<int> collection;
    for (int i = 1; i <= 5; ++i) {
        collection.add(i);
    }
    
    std::cout << "Forward: ";
    for (auto it = collection.begin(); it != collection.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    std::cout << "Reverse: ";
    for (auto it = collection.rbegin(); it != collection.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

总结
迭代器模式是C++中非常重要的设计模式，它：

提供统一的遍历接口：无论底层数据结构如何，都能使用相同的方式遍历

支持多种遍历算法：可以根据需要实现不同的遍历策略

符合开闭原则：添加新的遍历方式不需要修改现有代码

与STL完美集成：C++标准库大量使用迭代器模式

在实际开发中，迭代器模式常用于：

自定义容器的实现

复杂数据结构的遍历

数据过滤和转换操作

提供与STL算法兼容的接口

【c++设计模式18】行为模式3：迭代器模式（Iterator Pattern）
junxuezheng的博客
06-17 829
迭代器模式定义了一个迭代器接口（Iterator），该接口包含了对容器对象（如列表或集合）进行遍历的方法。具体容器对象（Concrete Collection）实现了迭代器接口，并且提供了创建迭代器对象的方法。迭代器对象（Iterator Object）封装了对容器对象的访问和遍历逻辑。
C++设计模式之迭代器模式
K1_uestc的博客
01-23 1574
迭代器模式是⼀种行为设计模式，是⼀种使⽤频率⾮常⾼的设计模式，在各个语⾔中都有应用，其主要⽬的是提供⼀种统⼀的⽅式来访问⼀个聚合对象中的各个元素，而不需要暴露该对象的内部表示。通过迭代器，客户端可以顺序访问聚合对象的元素，而无需了解底层数据结构。
c++ 设计模式 迭代器模式
2403_84775671的博客
04-26 942
基本类型（和指针的定义方法一致）类型 *迭代器变量名;举例int *iter;容器类型（以string为例，后续会详细学容器）
C++设计模式---迭代器模式
专注
07-04 615
是⼀种使⽤频率⾮常⾼的设计模式，在各个语⾔中都有应用，其主要⽬的是提供⼀种统⼀的⽅式来访问⼀个聚合对象中的各个元素，而不需要暴露该对象的内部表示。：定义访问和遍历元素的接⼝, 通常会包括hasNext() ⽅法⽤于检查是否还有下⼀个元素，以及next() ⽅法⽤于获取下⼀个元素。：实现在抽象聚合类中声明的createIterator() ⽅法，返回⼀个与具体聚合对应的具体迭代器。：定义了创建迭代器的接⼝，包括⼀个createIterator ⽅法⽤于创建⼀个迭代器对象。
C++设计模式 | Iterator迭代器模式详解
Lebron
05-12 1573
文章目录迭代器模式的含义迭代器模式的基本实现 迭代器模式的含义 迭代器模式Iterator的核心功能，就是提供了一种特定的方法，顺序访问一个容器中的各个元素，既不会暴露容器的内部设计细节（容器底层数据结构），又可以让外部代码透明的访问集合内部的所有元素。 所以迭代器模式的代码中首先有两个成员方法，一个是判断是否存在下一个元素存在（bool hasnext（））和取出下一个元素（_Ty& n...
篇十九：迭代器模式：遍历集合
Jake_cai的博客
08-08 920
迭代器模式是一种重要的设计模式，它通过将集合的遍历逻辑封装在迭代器中，提供了一种统一的方式来访问集合中的元素。设计模式是软件开发中的重要知识，迭代器模式（Iterator Pattern）是一种行为型设计模式，用于提供一种统一的方式遍历集合中的元素，而无需暴露集合的内部表示。在迭代器模式中，通过将集合的遍历逻辑封装在迭代器中，实现了集合的遍历和客户端代码的解耦。迭代器模式的关键在于将遍历集合的逻辑封装在迭代器中，从而使得客户端代码与集合的具体表示解耦，提高了代码的灵活性和可维护性。
C++：迭代器
博客网站 https://async-area.com
02-13 2348
讲解C++的迭代器概念及基础用法
【设计模式学习笔记】解释器模式、迭代器模式案例详解（C++实现）
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-26 983
行为型设计模式之解释器模式、迭代器模式简介及C++案例实现。
迭代器模式
如无必要，勿增实体。
10-02 1112
迭代器模式通过提供一种统一的方式来遍历聚合对象中的元素，而不需要暴露聚合对象的内部表示。它将集合对象的遍历行为从业务逻辑中分离出来，使得外部代码可以透明地访问集合内部数据，同时不暴露集合的内部结构。迭代器模式在Java等面向对象编程语言中被广泛应用，特别是在集合框架中。
c++之stack_queue与反向迭代器的实现
weixin_60358305的博客
04-09 1182
1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:empty：检测队列是否为空size：返回队列中有效元素的个数返回队头元素的引用返回队尾元素的引用push_back。
C++设计模式之迭代器模式（Iterator）
08-27
迭代器模式的结构主要包括以下几个部分： * 迭代器（Iterator）：定义了访问聚合对象的接口，提供了一些基本的操作，例如first()、next()、hasnext()和current()等。 * 容器（Container）：提供了一些基本的操作，...
设计模式C++学习之迭代器模式（Iterator）
09-07
迭代器模式是软件设计模式中的行为模式之一，它在C++编程中有着广泛的应用。这个模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。通过迭代器，用户可以遍历集合中的所有元素，而无需知道如何...
C++迭代器模式个人源码实现及参考代码
06-21
源码实现迭代器模式时，通常包含以下几个关键部分： 1. **聚合类（Aggregate）**：这是包含一组元素的对象，可以是数组、链表或其他容器。在C++中，这通常由一个类或结构体表示，例如`std::vector`、`std::list`等...
Go语言中的迭代器模式与安全访问实践
ALex_zry的博客
08-21 694
摘要：本文探讨了Go语言中迭代器模式的实现与安全访问实践。传统迭代器模式在Go中演进为更符合语言特性的实现方式，包括基于函数的迭代器、通道式迭代器以及泛型迭代器（Go 1.18+）。文章重点介绍了安全访问模式，涵盖边界安全（如切片安全访问和并发安全迭代器）和资源安全（如自动关闭迭代器）。现代Go迭代器模式包括生成器模式、可取消迭代器和异步批处理迭代器。最后讨论了错误处理与恢复机制，如带错误传播的迭代器和panic恢复机制。这些模式展示了如何在Go中构建高效、安全的迭代器实现。
C++ 运算符：从基础到高阶的完整指南
最新发布
正在在摸鱼的博客
08-22 330
运算符重载是C++支持多态性的核心特性之一，允许程序员为自定义类型赋予运算符的语义化操作能力。其本质是通过函数重载机制实现的，编译器会根据操作数类型选择最匹配的运算符函数。+=
C++高频知识点（三十一）
Atticus的博客
08-20 379
本文摘要了5个技术问题： 在1GB物理内存中malloc 2GB可能成功，因现代系统支持虚拟内存； 同名同参函数可通过const重载，编译器能区分const和非const版本； GET与POST区别：GET参数在URL可见有长度限制，POST通过请求体传输更安全； Redis持久化机制：RDB快照恢复快但可能丢数据，AOF日志更安全但文件较大，推荐混合模式； ++i返回自增后引用（高效），i++返回原值副本（需临时对象）。 （字数：149）
C++ STL -4 | vector
电子异术博物馆
08-22 530
介绍C++中std::vector的使用技巧与底层机制。重点包括：1）vector的动态数组特性与基本操作；2）容量管理（size/capacity区别、预分配优化）；3）底层实现（连续存储、扩容机制）；4）特殊用法（swap回收内存、emplace高效构造）；5）vector<bool>的特化实现与陷阱；6）开发注意事项（迭代器失效、性能优化等）。适合有一定基础的开发者掌握vector的进阶特性，提升使用效率与规避常见错误。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值