C++ 反向迭代器的设计与实现

简介: C++ 反向迭代器的设计与实现

在本文开始之前,先明晰几个 关键词 的含义(T : 模板参数):

  • Ref : T& / const T&
  • Ptr : T* / const T*

一、反向迭代器设计的上帝视角

我们希望将 反向迭代器 设计成一种适配器——传 list::iterator 得到 list 的反向迭代器,传 vector::iterator 得到 vector 的反向迭代器。

template<class Iterator>
struct ReverseIterator
{
  Iterator cur;
    
    ReverseIterator(const Iterator& it)
        :cur(it)
    {}
};

STL 中,(正向)迭代器和反向迭代器是一种对称设计——rend() == begin() ,rbegin() == end() :

对于反向迭代器重载++ / – ,我们只需要复用正向迭代器的 – / ++ 即可。

不过,需要注意的是,反向迭代器调用 it.operator*() 应取到 it 的前一个位置的数据(取数据时,不改变 it 的位置)。

二、运算符重载细节介绍

为了使我们的反向迭代器能快速用起来,优先实现 ++ , * , -> , != 等功能,其余以此类推。

  • 重载 ++
template<class Iterator>
struct ReverseIterator
{
    ReverseIterator<Iterator>& operator++()
    {
        --cur;
        return *this;
  }
    
    ReverseIterator<Iterator> operator++(int)
    {
        Iterator tmp = cur;
        --cur;
        return tmp;// 存在隐式类型转换 <--> ReverseIterator<Iterator>(tmp);
  }
};

“为什么前置++ 的返回值不能是 cur ?”

error C2440: “return”: 无法从“Iterator”转换为“ReverseIterator<int *> &”
  • 重载 * :引入一个模版参数 Ref
template<class Iterator, class Ref>
struct ReverseIterator
{
    Ref operator*()
    {
        Iterator tmp = cur;
        --tmp;
        return *tmp;
    }
};

当 tmp 的类型是 list::iterator,我们调用的 --tmp; return *tmp; ,编译器会调用 list 迭代器的运算符重载。

  • 重载 ->
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
    Ptr operator->()
    {
        return &(operator*());
  }
};
  • 重载 !=
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
    bool operator!=(const ReverseIterator<Iterator, Ref, Ptr>& l)
    {
        return cur != l.cur;
  }
};

ReverseIterator<Iterator, Ref, Ptr> 太长太过复杂,我们可以利用 typedef 进行简化。

template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
    typedef ReverseIterator<Iterator, Ref, Ptr> Self;
    bool operator!=(const Self& l)
    {
        return cur != l.cur;
  }
};

PS: typedef ... 应放在 public 区域,否则非成员函数无法使用 typedef 后的命名

全部代码:

template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
  Iterator cur;

  typedef ReverseIterator<Iterator, Ref, Ptr> Self;

  ReverseIterator(const Iterator& it)
    :cur(it)
  {}

  Self& operator++()
  {
    --cur;
    return *this;
  }

  Self operator++(int)
  {
    Iterator tmp = cur;
    --cur;
    return tmp;// 隐式类型转换
  }

  Self& operator--()
  {
    ++cur;
    return *this;
  }

  Self operator--(int)
  {
    Iterator tmp = cur;
    ++cur;
    return tmp;
  }

  Ref operator*()
  {
    Iterator tmp = cur;
    --tmp;
    return *tmp;
  }

  bool operator!=(const Self& s)
  {
    return cur != s.cur;
  }

  bool operator==(const Self& s)
  {
    return cur == s.cur;
  }

  Ptr operator->()// -> 返回数据的地址
  {
    return &(operator*());
  }
};
相关文章
|
4天前
|
编译器 C语言 C++
C++ STL中list迭代器的实现
C++ STL中list迭代器的实现
C++ STL中list迭代器的实现
|
9天前
|
算法 数据处理 C++
C++一分钟之-迭代器与算法
【6月更文挑战第21天】C++ STL的迭代器统一了容器元素访问,分为多种类型,如输入、输出、前向、双向和随机访问。迭代器使用时需留意失效和类型匹配。STL算法如查找、排序、复制要求特定类型的迭代器,注意容器兼容性和返回值处理。适配器和算法组合增强灵活性,但过度使用可能降低代码可读性。掌握迭代器和算法能提升编程效率和代码质量。
23 3
|
24天前
|
存储 编译器 Linux
C++初阶学习第十弹——探索STL奥秘(五)——深入讲解vector的迭代器失效问题
C++初阶学习第十弹——探索STL奥秘(五)——深入讲解vector的迭代器失效问题
28 7
|
5天前
|
算法 编译器 Linux
【C++/STL】:vector容器的底层剖析&&迭代器失效&&隐藏的浅拷贝
【C++/STL】:vector容器的底层剖析&&迭代器失效&&隐藏的浅拷贝
9 0
|
1月前
|
C语言
从C语言到C++_29(红黑树封装set和map)红黑树迭代器的实现(下)
从C语言到C++_29(红黑树封装set和map)红黑树迭代器的实现
28 3
|
1月前
|
算法 C语言 C++
从C语言到C++_20(仿函数+优先级队列priority_queue的模拟实现+反向迭代器)(下)
从C语言到C++_20(仿函数+优先级队列priority_queue的模拟实现+反向迭代器)
13 0
从C语言到C++_20(仿函数+优先级队列priority_queue的模拟实现+反向迭代器)(下)
|
15天前
|
存储 缓存 编译器
【C++进阶】深入STL之list:模拟实现深入理解List与迭代器
【C++进阶】深入STL之list:模拟实现深入理解List与迭代器
11 0
|
15天前
|
编译器 C++ 容器
【C++进阶】深入STL之vector:深入研究迭代器失效及拷贝问题
【C++进阶】深入STL之vector:深入研究迭代器失效及拷贝问题
21 0
|
1月前
|
编译器 测试技术 C语言
从C语言到C++_29(红黑树封装set和map)红黑树迭代器的实现(上)
从C语言到C++_29(红黑树封装set和map)红黑树迭代器的实现
12 0
|
1天前
|
C++
【C++】日期类Date(详解)②
- `-=`通过复用`+=`实现,`Date operator-(int day)`则通过创建副本并调用`-=`。 - 前置`++`和后置`++`同样使用重载,类似地,前置`--`和后置`--`也复用了`+=`和`-=1`。 - 比较运算符重载如`&gt;`, `==`, `&lt;`, `&lt;=`, `!=`,通常只需实现两个,其他可通过复合逻辑得出。 - `Date`减`Date`返回天数,通过迭代较小日期直到与较大日期相等,记录步数和符号。 ``` 这是236个字符的摘要,符合240字符以内的要求,涵盖了日期类中运算符重载的主要实现。