C++如何使用STL反向迭代器rbegin和rend

P粉602998670

发布时间：2025-09-18 12:01:01

978人浏览过

来源于php中文网

原创

rbegin()和rend()返回反向迭代器，用于从容器末尾向前遍历：rbegin()指向最后一个元素，rend()指向首元素前一位置；其行为在所有STL容器中一致，但“末尾”含义依容器排序规则而定，如vector按物理顺序、map按键值降序。

c++如何使用stl反向迭代器rbegin和rend

在C++中，

rbegin()

和

rend()

是STL容器提供的两个成员函数，它们返回反向迭代器，允许我们从容器的末尾向开头遍历。简单来说，

rbegin()

指向容器的最后一个元素，而

rend()

则指向容器的第一个元素“之前”的位置（一个逻辑上的“哨兵”值），这样当我们从

rbegin()

开始，不断递增迭代器直到

rend()

时，就完成了从后向前的遍历。

解决方案

使用

rbegin()

和

rend()

来反向遍历STL容器非常直观。它们返回的类型是

std::reverse_iterator

，这种迭代器在行为上与普通迭代器相反：对其执行

++

操作会使其向容器的起始方向移动，而

--

操作则使其向容器的末尾方向移动。

以

std::vector

为例，假设我们有一个整数向量，想从最后一个元素开始打印到第一个元素：

#include 
#include 
#include 
#include 
#include  // for std::sort if needed

int main() {
    std::vector numbers = {10, 20, 30, 40, 50};
    std::cout << "Vector elements (reverse): ";
    for (auto it = numbers.rbegin(); it != numbers.rend(); ++it) {
        std::cout << *it << " "; // *it 会解引用到当前指向的元素
    }
    std::cout << std::endl;

    std::string s = "Hello, C++!";
    std::cout << "String characters (reverse): ";
    for (auto it = s.rbegin(); it != s.rend(); ++it) {
        std::cout << *it;
    }
    std::cout << std::endl;

    std::list prices = {1.1, 2.2, 3.3, 4.4};
    std::cout << "List elements (reverse): ";
    for (auto it = prices.rbegin(); it != prices.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 对于const容器或const引用，需要使用const_reverse_iterator
    const std::vector& const_numbers = numbers;
    std::cout << "Const Vector elements (reverse): ";
    for (auto it = const_numbers.rbegin(); it != const_numbers.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

这里值得注意的是，

*it

解引用后得到的仍然是容器中的实际元素。

rbegin()

返回的迭代器指向的是容器中物理上的最后一个元素，而

rend()

返回的迭代器则是一个“过去末尾”的迭代器，它不指向任何有效元素，仅作为循环终止条件。这种设计哲学在STL中保持了高度的一致性，无论正向还是反向遍历，循环结构都是

for (auto it = begin(); it != end(); ++it)

的变体。

立即学习“C++免费学习笔记（深入）”；

C++ STL反向迭代器与正向迭代器有何不同？

这其实是个很有意思的问题，因为它们看起来只是方向反了，但底层实现和概念映射上有些巧妙之处。最核心的区别在于它们的“前进”方向和

base()

成员函数。

正向迭代器（

begin()

end()

返回的）的

++

操作会使其向容器的末尾移动，而反向迭代器（

rbegin()

rend()

返回的）的

++

操作则使其向容器的开头移动。这是它们的表面行为。

更深层次一点，一个

std::reverse_iterator

实际上是包装了一个普通（正向）迭代器。当你创建一个反向迭代器时，它内部会持有一个指向“当前元素后一个位置”的正向迭代器。听起来有点绕，对吧？举个例子：

如果一个正向迭代器

it

指向元素

，那么一个等效的反向迭代器

rit

，在解引用时也应该得到

。但是，

rit

内部持有的正向迭代器实际上是指向

的下一个元素。这样，当

rit

进行

++

操作时，它内部的正向迭代器会进行

--

操作，从而使

rit

“反向前进”到

的前一个元素。

Memories.ai

专注于视频解析的AI视觉记忆模型

下载

这种设计通过

base()

成员函数暴露出来。

rit.base()

会返回它内部持有的那个正向迭代器。比如，

numbers.rbegin().base()

会返回指向

numbers

中第一个元素之后的位置的迭代器（也就是

numbers.end()

），而

numbers.rend().base()

则返回指向

numbers

中第一个元素的迭代器（也就是

numbers.begin()

）。

这种映射关系初看可能有点反直觉，但它确保了

[rbegin(), rend())

这个区间在逻辑上与

[begin(), end())

是对应的，只是遍历方向不同。理解这一点，有助于在一些需要混合使用正向和反向迭代器的场景（比如，需要将反向迭代器转换为正向迭代器来调用某些只接受正向迭代器的算法时）避免犯错。我个人在调试一些复杂算法时，就经常需要搞清楚这种

base()

的对应关系，否则很容易差一位。

何时选择使用rbegin()和rend()进行容器遍历？

选择使用

rbegin()

和

rend()

的主要场景，当然是当你需要从容器的末尾开始处理元素，并逐步向前移动时。这不仅仅是代码简洁性的问题，更是语义清晰度的问题。

逆序处理数据： 最直接的应用。比如，你有一个日志列表，想从最新的日志开始展示；或者一个操作历史栈，需要从最近的操作开始回溯。
查找最后一个满足条件的元素： 虽然
```
std::find
```
通常是从前往后，但如果你想找最后一个出现的某个值，用反向迭代器遍历会更自然，一旦找到就可以停止。
字符串处理： 解析字符串时，有时需要从末尾开始扫描，例如检查文件扩展名、解析URL参数等。
算法实现： 某些算法的逻辑天然就是逆序的。例如，实现一个基于向量的栈，虽然通常用
```
push_back
```
/
```
pop_back
```
，但如果需要遍历栈的内容而不改变它，反向迭代器就很有用。
提高可读性： 这一点对我来说非常重要。虽然你可以通过
```
for (auto it = vec.end(); it != vec.begin(); --it)
```
（注意
```
--it
```
在
```
vec.begin()
```
之前停下，且
```
*--it
```
才是正确解引用方式）或者
```
for (int i = vec.size() - 1; i >= 0; --i)
```
来模拟反向遍历，但
```
rbegin()
```
和
```
rend()
```
的语义更明确，代码意图一目了然。这减少了出错的可能性，也让后来的维护者更容易理解你的代码。我见过太多因为手动管理索引或迭代器边界而导致的off-by-one错误了，
```
rbegin()
```
/
```
rend()
```
在很大程度上规避了这类问题。

总的来说，当你的业务逻辑要求“从后往前”时，就果断使用

rbegin()

和

rend()

。这不仅符合C++的惯用法，也让代码更具表达力。

反向迭代器在不同STL容器中的行为一致吗？

是的，从概念和接口层面来看，

rbegin()

和

rend()

在所有标准STL容器（包括

std::vector

std::list

std::deque

std::string

等序列容器，以及

std::set

std::map

std::multiset

std::multimap

等关联容器）中的行为是高度一致的。它们都返回一个

std::reverse_iterator

（或

const_reverse_iterator

），并且

++

操作使其向容器的开头移动，

操作解引用到当前元素。

然而，这种“一致性”是建立在抽象层面的。具体到不同容器的底层实现，它们的性能特征和“最后一个元素”的定义可能会有所不同：

序列容器（
vector
,
deque
,
list
,
string
）：对于这些容器，
```
rbegin()
```
指向的是物理上的最后一个元素，
```
rend()
```
指向的是物理上的第一个元素之前的位置。遍历的顺序就是元素在内存或链表中的逆序。性能上，
```
vector
```
和
```
deque
```
的反向迭代器通常是随机访问迭代器，
```
list
```
和
```
string
```
的反向迭代器是双向迭代器，这与它们的正向迭代器类型相匹配。
关联容器（
set
,
map
,
multiset
,
multimap
）：这些容器是基于某种排序（通常是红黑树）来存储元素的。对于它们，
```
rbegin()
```
指向的是容器中键值最大的那个元素，而
```
rend()
```
则指向键值最小的元素之前的位置。这里的“最后一个”和“第一个”是根据元素的排序规则来定义的，而不是物理存储顺序。所以，当你对
```
std::map
```
调用
```
rbegin()
```
时，它会给你键值最大的那个键值对。