C++自定义迭代器

最新推荐文章于 2025-07-21 15:58:22 发布
原创 最新推荐文章于 2025-07-21 15:58:22 发布 · 403 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

实现自己的迭代器

最近在写数据结构，使用类模板实现，碰到了一些问题，其中有一个就是遍历的问题，查阅资料最后实现了自己的迭代器，让我实现的数据结构能像STL一样进行for循环遍历。

类的构成

#include <stdexcept>
#include <iterator>
template <typename T>
class Queue
{
public:
    // 迭代器
    class iterator;
    class const_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    Queue() : _capacity(5), _size(0), _items(new T[_capacity]), _front(0), _rear(-1) {}
    ~Queue();

    // 入队
    void enqueue(const T &item);
    // 出队
    T dequeue();
    // 查看队首元素
    T front() const;
    // 查看队尾元素
    T rear() const;
    // 获取队列元素数量
    unsigned int size() const;

    iterator begin() noexcept;
    iterator end() noexcept;
    const_iterator begin() const noexcept;
    const_iterator end() const noexcept;
    reverse_iterator rbegin() noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    const_reverse_iterator rend() const noexcept;

private:
    // 存储元素的数组
    T *_items;
    // 队列当前容量
    unsigned int _capacity;
    // 队列当前大小
    unsigned int _size;
    // 队首
    unsigned int _front;
    // 队尾
    unsigned int _rear;

    // 调整队列的大小
    void resize();
    // 判断队列是否为空
    bool empty() const;
    // 判断当前队列是否为满
    bool full() const;
};

可以看到，我声明了两个类iterator和const_iterator，这两个类就是需要我们自己定义的迭代器。

官方定义

template <class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
  struct iterator {
    typedef T         value_type;
    typedef Distance  difference_type;
    typedef Pointer   pointer;
    typedef Reference reference;
    typedef Category  iterator_category;
  };

对于官方定义的迭代器结构，有5个参数，在后续实现自己的迭代器使需要设置。

自定义迭代器的实现

iterator

template <typename T>
class Queue<T>::iterator
{
public:
    // 标准写法
    // 迭代器的类型
    using iterator_category = std::bidirectional_iterator_tag;
    // 数据类型
    using value_type = T;
    // 迭代器之间的逻辑距离
    using difference_type = std::ptrdiff_t;
    // 指针
    using pointer = T*;
    // 引用
    using reference = T&;

    // 构造函数
    iterator(pointer data = nullptr,
             unsigned int pos = 0,
             unsigned int capacity = 0,
             unsigned int start = 0,
             unsigned int size = 0)
        : _data(data), _pos(pos), _capacity(capacity), _start(start), _size(size) {}

    // 实现运算符重载
    // 解引用
    reference operator*() const 
    {
        return this->_data[(this->_start + this->_pos) % this->_capacity];
    }
    // 成员访问
    pointer operator->() const
    {
        return &(operator*());
    }
    // 前++运算符
    iterator& operator++()
    {
        ++this->_pos;
        return *this;
    }
    // 后++运算符
    iterator operator++(int)
    {
        iterator tmp = *this;
        ++this->_pos;
        return tmp;
    }

    // 前--运算符
    iterator& operator--()
    {
        --this->_pos;
        return *this;
    }
    // 后--运算符
    iterator operator--(int)
    {
        iterator tmp = *this;
        --this->_pos;
        return tmp;
    }

    // 比较运算符
    bool operator==(const iterator& other) const
    {
        return this->_pos == other._pos;
    }
    bool operator!=(const iterator& other) const
    {
        return !(*this == other);
    }
    

private:
    pointer _data;          // 指向队列数据数组的指针
    unsigned int _pos;      // 当前逻辑位置
    unsigned int _capacity; // 队列容量
    unsigned int _start;    // 队列实际起始位置
    unsigned int _size;     // 队列当前元素数量
};

const_iterator

template <typename T>
class Queue<T>::const_iterator
{
    // 标准写法
    // 迭代器的类型
    using iterator_category = std::bidirectional_iterator_tag;
    // 数据类型
    using value_type = const T;
    // 迭代器之间的逻辑距离
    using difference_type = std::ptrdiff_t;
    // 指针
    using pointer = const T*;
    // 引用
    using reference = const T&;

    // 构造函数
    const_iterator(const pointer data = nullptr,
             unsigned int pos = 0,
             unsigned int capacity = 0,
             unsigned int start = 0,
             unsigned int size = 0)
        : _data(data), _pos(pos), _capacity(capacity), _start(start), _size(size) {}

    // 实现运算符重载
    // 解引用
    reference operator*() const 
    {
        return this->_data[(this->_start + this->_pos) % this->_capacity];
    }
    // 成员访问
    pointer operator->() const
    {
        return &(operator*());
    }
    // 前++运算符
    const_iterator& operator++()
    {
        ++this->_pos;
        return *this;
    }
    // 后++运算符
    const_iterator operator++(int)
    {
        const_iterator tmp = *this;
        ++this->_pos;
        return tmp;
    }

    // 前--运算符
    const_iterator& operator--()
    {
        --this->_pos;
        return *this;
    }
    // 后--运算符
    const_iterator operator--(int)
    {
        const_iterator tmp = *this;
        --this->_pos;
        return tmp;
    }


    // 比较运算符
    bool operator==(const const_iterator& other) const
    {
        return this->_pos == other._pos;
    }
    bool operator!=(const const_iterator& other) const
    {
        return !(*this == other);
    }
    

private:
    pointer _data;          // 指向队列数据数组的指针
    unsigned int _pos;      // 当前逻辑位置
    unsigned int _capacity; // 队列容量
    unsigned int _start;    // 队列实际起始位置
    unsigned int _size;     // 队列当前元素数量
};

begin()和end()的实现

template <typename T>
typename Queue<T>::iterator Queue<T>::begin() noexcept
{
    return iterator(this->_items, 0, this->_capacity, this->_front, this->_size);
}

template <typename T>
typename Queue<T>::iterator Queue<T>::end() noexcept
{
    return iterator(this->_items, this->_size, this->_capacity, this->_front, this->_size);
}

template <typename T>
typename Queue<T>::const_iterator Queue<T>::begin() const noexcept
{
    return const_iterator(this->_items, 0, this->_capacity, this->_front, this->_size);
}

template <typename T>
typename Queue<T>::const_iterator Queue<T>::end() const noexcept
{
    return const_iterator(this->_items, this->_size, this->_capacity, this->_front, this->_size);
}

rbegin()和rend()的实现

template <typename T>
typename Queue<T>::reverse_iterator Queue<T>::rbegin() noexcept
{
    return reverse_iterator(this->end());
}

template <typename T>
typename Queue<T>::reverse_iterator Queue<T>::rend() noexcept
{
    return reverse_iterator(this->begin());
}

template <typename T>
typename Queue<T>::const_reverse_iterator Queue<T>::rbegin() const noexcept
{
    return const_reverse_iterator(this->end());
}

template <typename T>
typename Queue<T>::const_reverse_iterator Queue<T>::rend() const noexcept
{
    return const_reverse_iterator(this->begin());
}

其他代码自己就不放出来了，主要是为了说明自定义迭代器，可以参照我的代码实现自己的迭代器。

测试

void testQueue()
{
    Queue<int> que;
    que.enqueue(4);
    que.enqueue(2);
    que.enqueue(5);
    std::cout << que.rear() << std::endl;

    for(const auto& item : que)
    {
        std::cout << item << " ";
    }
    std::cout << std::endl;

    for(auto it = que.rbegin(); it != que.rend(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}


int main() {
    testQueue();
    return 0;
}

输出的结果为：

5
4 2 5
5 2 4
C++ STL Custom Iterator 自定义迭代器
GPU全栈博主
06-27 661
【代码】C++ STL 自定义迭代器(create a custom iterator)
c++新特性:让基于范围的for循环支持自定义类型
TOPEE362的博客
08-06 882
c++基于范围的for循环
C++中如何实现自定义类型的迭代器
热门推荐
XiaoHeiBlack的专栏
08-09 1万+
我们知道STL实现了很多算法，如果项目是基于STL构建那么能够最大化使用现有代码当然是最好的。在STL中容器和算法之间的桥梁是迭代器。所以在定义好自定义类型的容器后，接下来就是迭代器的实现。STL中的迭代器迭代器模式是一种经典的设计模式，而STL的迭代器实现用到了模板的一些特性和技能，其中的细节可以去参考《STL源码剖析》里面的内容，在这里稍微介绍一下下面是STL中结构体iterator的定义，
C++ 自定义迭代器
JIWilliams
12-10 2925
让我们在示例中看一个简单迭代器类型的定义。我们定义一个类模板，用来表示一段数值类型值，也可以生成指定范围的开始和结束迭代器。这个迭代器也是模板类型，两个模板都定义在同一个头文件 Numeric_Range.h 中。下面是 Numeric_Range&lt;T&gt; 模板的定义： template &lt;typename T&gt; class Numeric_Iterator; //...
【C++】深入理解C++迭代器：概念、分类与自定义实现
最新发布
卜及中的博客
07-21 1007
本文详细介绍了C++中的迭代器，包括其基本概念、作用、分类、本质；以及如何为自定义的容器编写迭代器。
C++自定义迭代器（STL）
qq_36745117的博客
11-08 1715
一.iterator_traits #include template &amp;amp;amp;amp;amp;amp;lt;class Iterator&amp;amp;amp;amp;amp;amp;gt; struct iterator_traits { typedef typename Iterator::difference_type differebce_type; typedef typename Iterator::value_type value_
C++——实现一个简单的迭代器
weixin_67452474的博客
10-14 4590
迭代器的实现
C++——自己实现一个迭代器，简单明了
小罗的学习博客
12-01 4084
/* 自定义迭代器的实现 */ #include <iostream> using namespace std; class num { int val; //具体的数字 int length; //数字的位数 void getlength(){ if(val/10==0){ //这个数字只有1位 ...
【C++自定义迭代器】：从理论到实践，打造高效迭代器的5个步骤
C++自定义迭代器概述 当我们深入学习C++编程时，会发现很多高级功能，比如算法和容器，都是通过迭代器模式来实现的。迭代器是为了解决如何遍历数据结构而出现的一种设计模式，它提供了一种方法，允许我们逐一访问...
深入探索：在 C++ 中构建自定义迭代器
11-29
在 C++ 中实现自定义迭代器是一项具有挑战性但非常有价值的任务。通过自定义迭代器，我们可以更好地适配特殊的数据结构，优化元素遍历的效率，并提供统一的遍历接口。在实现过程中，需要深入理解迭代器的基本概念和...
迭代器模式（Iterator）C++实现
03-14
迭代器模式（Iterator）C++实现
C++ 标准库 自定义迭代器
2401_83484142的博客
11-12 245
第一种办法，C++ 标准库特意提供了一个特殊的基类 iterator<> ，专门用来进行自定义。
C++：使自定义类支持迭代器
weixin_42717586的博客
09-11 129
概述 在 C++ 中，链表迭代器是一种用来遍历链表（如 std::list）元素的工具。链表是一种数据结构，其中每个元素（节点）包含一个数据值和一个指向下一个节点的指针。链表迭代器允许以类似于数组的方式访问链表中的元素，但不需要直接操作指针。 链表迭代器的作用 访问元素：链表迭代器使你能够顺序访问链表中的每个元素，就像在数组中遍历元素一样。 遍历链表：通过迭代器，你可以在链表中前进或后...
c++实现一个自己的迭代器和ListSTL
qq_74050480的博客
05-16 269
c++实现一个自己的迭代器和ListSTL
【C++ 迭代器实现 终篇】深入理解C++自定义容器和迭代器的实现与应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-11 2530
在C++编程中，容器和迭代器是数据存储和访问的基石。自定义容器允许我们根据特定需求定制数据存储和访问机制，而迭代器则是连接容器和算法的桥梁。
【C++ 模板和迭代器的交融】灵活多变：使用C++模板精准打造自定义迭代器
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-07 694
C++模板是一种强大的工具，它允许程序员编写泛型代码，从而实现代码的重用和类型安全。在迭代器的设计中，模板技术能够帮助我们创建能够适应不同数据类型和数据结构的通用迭代器。
C++ 类 自定义迭代器
baby的专栏
05-08 1286
原来迭代器也是一种模式啊…
定义C++迭代器
Salted的博客
10-17 2517
定义C++迭代器 所有的STL容器都定义了： 该容器的迭代器类型，如：iterator、const_iterator 该容器的begin() end() 方法 没有定义上面两种的容器被看做二等公民，他们不能和泛型算法一起使用，为你的容器定义迭代器类型和begin、end方法，无论他们是否是泛型容器 来自被嵌套的STL容器的迭代器 若你的容器中使用了STL容器作为内部数据成员，那么只需要将迭代器和两个方法的实现托付给STL容器即可。 例如，假如你有一个类CourseList，它表示学生参加的课程的列表，在
自定义迭代器
03-31
### 创建或使用自定义迭代器的实现方法 #### C++ 中的自定义迭代器实现 在 C++ 中，可以通过继承 `std::iterator` 或者更现代的方式通过继承 `boost::iterator_facade` 来创建自定义迭代器。这种方式允许开发者灵活地控制迭代行为并支持 STL 风格的操作。 以下是基于 Boost 库的一个简单例子，展示如何构建一个随机访问类型的迭代器： ```cpp #include <boost/iterator/iterator_facade.hpp> #include <vector> class MyIterator : public boost::iterator_facade< MyIterator, int, boost::random_access_traversal_tag> { private: std::vector<int>::const_iterator current; public: explicit MyIterator(std::vector<int>::const_iterator it) : current(it) {} private: friend class boost::iterator_core_access; reference dereference() const { return *current; } bool equal(MyIterator const& other) const { return current == other.current; } void increment() { ++current; } void decrement() { --current; } difference_type distance_to(MyIterator const& other) const { return std::distance(current, other.current); } void advance(difference_type n) { std::advance(current, n); } }; ``` 上述代码展示了如何利用 `boost::iterator_facade` 构建一个简单的随机访问迭代器[^2]。该迭代器封装了底层容器（这里是 `std::vector<int>` 的常量迭代器），并通过重载必要的操作符来满足 STL 要求。 --- #### Python 中的自定义迭代器实现 在 Python 中，自定义迭代器通常涉及实现两个特殊方法：`__iter__()` 和 `__next__()`。如果希望支持切片或其他复杂功能，则还需要额外重载其他方法，比如 `__getitem__()` 和 `__len__()`。 下面是一个示例，演示如何为一个简单的数据结构创建迭代器： ```python class MyCustomContainer: def __init__(self, data): self.data = data self.index = 0 def __iter__(self): # 返回迭代器对象本身 return self def __next__(self): # 定义每次调用 next() 方法的行为 if self.index >= len(self.data): raise StopIteration # 停止迭代条件 value = self.data[self.index] self.index += 1 return value container = MyCustomContainer([1, 2, 3]) for item in container: print(item) ``` 此代码片段实现了基本的迭代逻辑，并能够用于循环语句中。对于更加复杂的场景，还可以扩展此类以支持索引访问和其他特性[^4]。 --- #### 关键技术点总结 无论是 C++ 还是 Python，在设计自定义迭代器时都需要考虑以下几个方面： - **接口一致性**：确保遵循目标语言的标准协议（如 C++ 的 STL 协议或 Python 的迭代器协议）。 - **性能优化**：针对特定需求调整内部存储机制和算法效率。 - **灵活性增强**：提供多种遍历模式的支持（前向、双向或者随机访问）[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ht巷子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值