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

最新推荐文章于 2024-07-28 21:35:11 发布

繁星璀璨G

最新推荐文章于 2024-07-28 21:35:11 发布

阅读量1k

点赞数 20

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

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

版权

迭代器库专栏收录该内容

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() 所返回的迭代器。

成员类型

成员类型定义

iterator_type Iter

iterator_concept
(C++20 起) 若 Iter 实现 std::random_access_iterator ，则为 std::random_access_iterator_tag 。否则为 std::bidirectional_iterator_tag

iterator_category

std::iterator_traits<Iter>::iterator_category	(C++20 前)
若 std::iterator_traits<Iter>::iterator_category 实现 std::derived_from<std::random_access_iterator_tag> ，则为 std::random_access_iterator_tag 。否则为不更改的 std::iterator_traits<Iter>::iterator_category	(C++20 起)

value_type

std::iterator_traits<Iter>::value_type	(C++20 前)
std::iter_value_t<Iter>	(C++20 起)

difference_type

std::iterator_traits<Iter>::difference_type	(C++20 前)
std::iter_difference_t<Iter>	(C++20 起)

pointer std::iterator_traits<Iter>::pointer

reference

std::iterator_traits<Iter>::reference	(C++20 前)
std::iter_reference_t<Iter>	(C++20 起)

要求通过从 std::iterator<std::iterator_traits<Iter>::iterator_category
, std::iterator_traits<Iter>::value_type
, std::iterator_traits<Iter>::difference_type
, std::iterator_traits<Iter>::pointer
, std::iterator_traits<Iter>::reference
> 继承获得成员类型 iterator_category 、 value_type 、 difference_type 、 pointer 及 reference 。

(C++17 前)

成员函数

(构造函数)	构造新的迭代器适配器 (公开成员函数)
operator=	赋值另一迭代器 (公开成员函数)
base	访问底层迭代器 (公开成员函数)
operator*operator->	访问指向的元素 (公开成员函数)
operator[]	按索引访问元素 (公开成员函数)
operator++operator++(int)operator+=operator+operator--operator--(int)operator-=operator-	推进或回退迭代器 (公开成员函数)

成员对象


成员名称	定义
`current` (受保护成员对象)	base() 迭代器的副本

非成员函数

make_reverse_iterator (C++14)	创建拥有从实参推出的类型的 std::reverse_iterator (函数模板)
operator==operator!=operator<operator<=operator>operator>=	比较底层迭代器 (函数模板)
operator+	令迭代器前进 (函数模板)
operator-	计算两个迭代器适配器间的距离 (函数模板)
iter_move (C++20)	转型解引用调整后的底层迭代器的结果为其所关联的右值引用类型 (函数模板)
iter_swap (C++20)	交换二个调整后的底层迭代器所指向的对象 (函数模板)

注意

std::reverse_iterator 不可作用于返回到成员对象引用的迭代器（是谓“隐匿迭代器”）。隐匿迭代器的一个例子是 std::filesystem::path::iterator 。

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <deque>
#include <algorithm>
#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::string string = "Hello, world";
    std::reverse_iterator<std::string::iterator> reverse_iterator = string.rbegin();
    string[7] = 'O'; // 以 'O' 替换 'o'
    string += 7; // 迭代器现在指向 'O'
    alg(reverse_iterator, reverse_iterator);
    std::cout << "string:   " << string << std::endl;
    std::string reverse_string(reverse_iterator, string.rend());
    std::cout << "reverse_string:   " << reverse_string << std::endl;
    std::cout << std::endl;

    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 << " ";
        }
        std::cout << std::endl;
        alg(deque1.rbegin(), deque1.rend());
    }

    return 0;
}

输出

alg() called for random-access iterator
string:   Hello, Oorld
reverse_string:   dlroO ,olleH

deque1 :  {109,109} {106,106} {101,101} {107,107} {103,103} {102,102}
deque1 reverse :  {102,102} {103,103} {107,107} {101,101} {106,106} {109,109}
alg() called for random-access iterator

繁星璀璨G

关注

20
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
C++标准模板（STL）- 迭代器库-迭代器适配器 - 逆序遍历的迭代器适配器

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

扫一扫

专栏目录