`reverse_iterator`迭代器结构设计¶

约 936 个字 138 行代码 5 张图片预计阅读时间 5 分钟

前面的list类以及vector类设计了正向迭代器，现在考虑设计反向迭代器，常规的设计思路为单独为反向迭代器建一个新类，这个类中所有的函数全部重新设计，这种思路可取但是并不高效，可以考虑下面的设计思路：

前面了解到了容器适配器，那么是否也可以把正向迭代器设置为反向迭代器的容器适配器从而实现反向迭代器的效果

对于此时的反向迭代器类设计即为如下：

以list类为例

`reverse_iterator`迭代器基本结构设计¶

C++
//反向迭代器
 template<classIterator>
 class_list_reverse_iterator
 {
     typedef_list_reverse_iterator self;
     //使用正向迭代器构造反向迭代器
     _list_reverse_iterator(Iterator it)
         :_it(it)
     {}

 private:
     Iterator_it;
 };

`operator*()`函数¶

首先是对于operator*()函数来说，解引用操作符获得的结果即为指针当前指向中的内容，而在正向迭代器中，解引用操作符也是同样的作用，所以此处可以复用正向迭代器的解引用操作符，但是此处是Iterator类对象，所以不能使用传统的直接对内置类型解引用的方式，但是可以考虑直接调用Iterator类中的operator*()函数

对于返回值来说，可以考虑和设计const版本的正向迭代器思路一致，使用模板参数区分传递T&和T*

所以修改原来的类定义为：

C++
//反向迭代器
 template<class Iterator, class Ref, class Ptr>
 class _list_reverse_iterator
 {
     typedef _list_reverse_iterator self;
     //使用正向迭代器构造反向迭代器
     _list_reverse_iterator(Iterator it)
         :_it(it)
     {}

 private:
     Iterator _it;
 };

此时的operator*()函数即为如下设计：

C++
//operator*()函数
 Ref operator*()
 {
     return _it.operator*();
 }

operator++()函数¶

对于前置++运算符来说，不同于正向迭代器，因为正向迭代器++是从第一个有效数据节点开始一直到头节点结束，而对于反向迭代器来说，其++是从最后一个有效数据节点开始向前一直到头节点结束，如下图所示：

但是可以考虑通过正向迭代器适配出反向迭代器，具体思路如下：

将begin()放置在最后一个有效数据节点的位置，即end()-1的位置，将end()放在头节点的位置即可

所以，operator++()函数可以设计为

C++
//operator++()函数
self& operator++()
{
    --_it;
    return *this;
}

`operator->()`函数¶

同operator*()函数一样，调用Iterator中的operator->()函数即可

C++
//operator->()函数
 Ptr operator->()
 {
     return _it.operator->();
 }

`operator!=()`函数¶

同正向迭代器中的设计思路一致

C++
//operator!=()函数
bool operator!=(self& s)
{
    return _it != s._it;
}

`rbegin()`函数¶

C++
//rbegin()函数——反向——非const版本
reverse_iterator rbegin()
{
    //因为正向迭代器中没有重载-，所以使用--代替
    return reverse_iterator(--end());
}

`rend()`函数¶

C++
//rend()函数——反向——非const版本
reverse_iterator rend()
{
    return reverse_iterator(end());
}

`operator--()`函数¶

C++
//operator--()函数
self& operator--()
{
    ++_it;
    return *this;
}

`operator==()`函数¶

C++
//operator==()函数
bool operator==(const self& s)
{
    return _it == s._it;
}

测试代码¶

此时基本的反向迭代器框架已经搭建完成，下面是测试代码：

C++
void test_reverse_iterator()
{
    sim_list::list<int> ls;
    ls.push_back(1);
    ls.push_back(2);
    ls.push_back(3);
    ls.push_back(4);
    ls.push_back(5);

    sim_list::list<int>::reverse_iterator rit = ls.rbegin();
    while (rit != ls.rend())
    {
        cout << *rit << " ";
        ++rit;
    }
}

`const_reverse_iterator`迭代器设计¶

对于const_reverse_iterator设计来说，不需要更改reverse_iterator迭代器的结构，只需要在list类中重定义一个const版本即可

C++
typedef _list_reverse_iterator<iterator, T&, T*> reverse_iterator;// 反向迭代器——非const版本
typedef _list_reverse_iterator<iterator, const T&, const T*> const_reverse_iterator // 反向迭代器——const版本

并且将rbegin()和rend()分别重载一个const版本

C++
//rbegin()函数——反向——const版本
reverse_iterator rbegin() const
{
    //因为正向迭代器中没有重载-，所以使用--代替
    //注意end()此处是常量，但是此处是调用了operator--()，所以可以调用(编译器对const类型能调用普通函数的优化)，如果是内置指针类型则必须写成end()-1
    return reverse_iterator(--end());
}

//rend()函数——反向——const版本
reverse_iterator rend() const
{
    return reverse_iterator(end());
}