C++标准模板（STL）- 迭代器库-迭代器适配器 - 逆序遍历的迭代器适配器（三）

最新推荐文章于 2024-11-09 20:38:27 发布

繁星璀璨G

最新推荐文章于 2024-11-09 20:38:27 发布

阅读量1k

点赞数 8

分类专栏：迭代器库文章标签： c++ 开发语言 STL reverse _iterator

本文链接：https://blog.csdn.net/qq_40788199/article/details/139396839

版权

迭代器库专栏收录该内容

38 篇文章 0 订阅

订阅专栏

迭代器库-迭代器原语

迭代器库提供了五种迭代器的定义，同时还提供了迭代器特征、适配器及相关的工具函数。

迭代器分类

迭代器共有五 (C++17 前)六 (C++17 起)种：遗留输入迭代器 (LegacyInputIterator) 、遗留输出迭代器 (LegacyOutputIterator) 、遗留向前迭代器 (LegacyForwardIterator) 、遗留双向迭代器 (LegacyBidirectionalIterator) 、遗留随机访问迭代器 (LegacyRandomAccessIterator) ，及遗留连续迭代器 (LegacyContiguousIterator) (C++17 起)。

迭代器的分类的依据并不是迭代器的类型，而是迭代器所支持的操作。换句话说，某个类型只要支持相应的操作，就可以作为迭代器使用。例如，完整对象类型指针支持所有遗留随机访问迭代器 (LegacyRandomAccessIterator) 要求的操作，于是任何需要遗留随机访问迭代器 (LegacyRandomAccessIterator) 的地方都可以使用指针。

迭代器的所有类别（除了遗留输出迭代器 (LegacyOutputIterator) 和遗留连续迭代器 (LegacyContiguousIterator) ）能组织到层级中，其中更强力的迭代器类别（如遗留随机访问迭代器 (LegacyRandomAccessIterator) ）支持较不强力的类别（例如遗留输入迭代器 (LegacyInputIterator) ）的所有操作。若迭代器落入这些类别之一且亦满足遗留输出迭代器 (LegacyOutputIterator) 的要求，则称之为可变迭代器并且支持输入还有输出。称非可变迭代器为常迭代器。

逆序遍历的迭代器适配器

std::reverse_iterator

template< class Iter > class reverse_iterator : public std::iterator< typename std::iterator_traits<Iter>::iterator_category, typename std::iterator_traits<Iter>::value_type, typename std::iterator_traits<Iter>::difference_type, typename std::iterator_traits<Iter>::pointer, typename std::iterator_traits<Iter>::reference >		(C++17 前)
template< class Iter > class reverse_iterator;		(C++17 起)

std::reverse_iterator 是一个反转给定迭代器方向的迭代器适配器。换言之，提供双向迭代器时， std::reverse_iterator 产生一个新的迭代器，它从底层的双向迭代器所定义的序列的末尾移动到开端。

对于从迭代器 i 构造的 r 逆向迭代器，关系 &*r == &*(i-1) 始终为 true （只要 r 可解引用）；从而构造自末尾后一位置的迭代器的逆向迭代器解引用到序列的最后元素。

这是标准库容器的成员函数 rbegin() 及 rend() 所返回的迭代器。

访问底层迭代器

std::reverse_iterator<Iter>::base

iterator_type base() const;		(C++17 前)
constexpr iterator_type base() const;		(C++17 起)

返回底层迭代器。即 std::reverse_iterator(it).base() == it 。

底层迭代器指代（从 std::reverse_iterator::iterator_type 视角的） reverse_iterator 当前所指元素的下一个元素。即 &*(rit.base() - 1) == &*rit 。

参数

（无）

返回值

底层迭代器。

异常

（无）

访问指向的元素

std::reverse_iterator<Iter>::operator*,->

reference operator*() const;	（1）	(C++17 前)
constexpr reference operator*() const;	（1）	(C++17 起)
pointer operator->() const;	(2)	(C++17 前)
constexpr pointer operator->() const;		(C++17 起)

返回指向 current 前一元素的引用或指针。

1) 等价于 Iter tmp = current; return *--tmp;

2) 等价于 std::addressof(operator*()) 。

参数

（无）

返回值

指向 current 前一元素的引用或指针。

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <deque>
#include <algorithm>
#include <typeinfo>
#include <time.h>

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }

    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

template< class BDIter >
void alg(BDIter, BDIter, std::input_iterator_tag)
{
    //遗留输入迭代器
    std::cout << "alg() called for input iterator" << std::endl;
}

template< class BDIter >
void alg(BDIter, BDIter, std::output_iterator_tag)
{
    //遗留输出迭代器
    std::cout << "alg() called for output iterator" << std::endl;
}

template< class BDIter >
void alg(BDIter, BDIter, std::forward_iterator_tag)
{
    //遗留向前迭代器
    std::cout << "alg() called for forward iterator" << std::endl;
}

template< class BDIter >
void alg(BDIter, BDIter, std::bidirectional_iterator_tag)
{
    //遗留双向迭代器
    std::cout << "alg() called for bidirectional iterator" << std::endl;
}

template <class RAIter>
void alg(RAIter, RAIter, std::random_access_iterator_tag)
{
    //遗留随机访问迭代器
    std::cout << "alg() called for random-access iterator" << std::endl;
}

template< class Iter >
void alg(Iter first, Iter last)
{
    alg(first, last,
        typename std::iterator_traits<Iter>::iterator_category());
}

int main()
{
    std::mt19937 g{std::random_device{}()};

    srand((unsigned)time(NULL));;

    std::cout << std::boolalpha;

    auto generate = []()
    {
        int n = std::rand() % 10 + 100;
        Cell cell{n, n};
        return cell;
    };

    std::deque<Cell> deque1(6);
    std::generate(deque1.begin(), deque1.end(), generate);
    std::cout << "deque1 :  ";
    std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::cout << "deque1 reverse :  ";
    for (std::deque<Cell>::reverse_iterator rit = deque1.rbegin(); rit != deque1.rend(); rit++)
    {
        std::cout << "{" << rit->x << "," << rit->y << "}" << " ";
    }
    std::cout << std::endl;
    alg(deque1.rbegin(), deque1.rend());

    std::reverse_iterator<std::deque<Cell>::iterator> reverse_begin(deque1.begin());
    std::reverse_iterator<std::deque<Cell>::iterator> reverse_end(deque1.end());
    for (std::reverse_iterator<std::deque<Cell>::iterator>::iterator_type rit
            = reverse_begin.base(); rit != reverse_end.base(); rit++)
    {
        std::cout << *rit << " ";
    }
    return 0;
}

输出

deque1 :  {109,109} {107,107} {103,103} {104,104} {107,107} {108,108}
deque1 reverse :  {108,108} {107,107} {104,104} {103,103} {107,107} {109,109}
alg() called for random-access iterator
{109,109} {107,107} {103,103} {104,104} {107,107} {108,108}