C++ std::reverse用法详解：从迭代器原理到容器反转实战

写 C++ 的 reverse，绕不开一个问题：很多人搜“c加加11以下能用 std reverse 吗”，其实在标准库里，std::reverse 从 C++98 那会儿就存在了，跟 C++11 没直接关系。但问题往往出在编译器对模板的支持程度、头文件的齐全度，以及你对迭代器的理解上。这篇就从 reverse 这个操作本身讲起，把标准库函数、手写方案、容器差异、常见坑一次说清，适合刚接触算法库的初学者，也适合准备面试时想理清细节的开发者。

1. 先把“reverse”这件事想清楚：一个函数背后的三种需求

反向操作在编程里太常用了。字符串倒序、数组翻转、链表反转、日志列表时间倒排，本质上都是同一件事：把一段连续或链式存储的元素，从头到尾的顺序调转过来。C++ 标准库给出的答案是 std::reverse，一个很小但极其重要的算法函数。

先说结论：std::reverse 是原地反转，不产生新容器，时间复杂度 O(n)，空间复杂度 O(1)。它对传入的迭代器区间 [first, last) 范围内的元素逐个交换，直到整个区间顺序完全倒过来。注意区间是左闭右开，last 指向的是最后一个元素的下一个位置，不是最后一个元素本身。

需求场景可以分成三类：

• 容器内元素反转：vector、deque、list、数组里的数据，希望原地倒序。
• 字符串反转：把字符串内容倒过来，常见于一些编码工具、进制转换、回文判断。
• 生成反转后的新副本：原数据不动，得到一个新的反转结果。

这三种需求，std::reverse 只直接解决前两种。第三种需要搭配 reverse_copy，或者自己构造目标容器再反向赋值。很多新手只盯着 reverse 一个函数，却不知道标准库里还有一个 reverse_copy，导致明明只需要一个副本，却被迫改了原数据，这种“踩坑”其实完全可以通过多看一眼函数签名避免。

另一个容易被忽略的点是：reverse 这个名字在 STL 里有两种形态。一种是通用算法的 std::reverse，需要传入迭代器范围；另一种是某些容器自带的成员函数，比如 list 就有 list.reverse()。通用算法适用于所有支持双向迭代器的容器，成员函数则是容器自己提供的优化版本。两者效果一样，但使用场景略有区别，后面会专门展开。

2. 从 std::reverse 到 reverse 家族：函数签名与版本兼容

2.1 标准库函数签名和头文件

用 std::reverse 之前，需要包含 头文件。函数签名是这样的：

template<class BidirIt> void reverse(BidirIt first, BidirIt last);

它接受一对双向迭代器。所谓“双向迭代器”，就是可以从前往后走，也可以从后往前走，比如 list、vector、deque、string、数组指针都满足。而 forward_list 这种单向链表只提供前向迭代器，不能用 std::reverse，得用成员函数或自己写循环。

C++17 之后又多了一个带执行策略的重载：

template<class ExecutionPolicy, class BidirIt> void reverse(ExecutionPolicy&& policy, BidirIt first, BidirIt last);

可以传入 std::execution::par 之类来启用并行版本。但日常开发里，用默认串行版本就够了，数据量没有大到需要并行反转时，加执行策略反而引入额外复杂度。

2.2 “C++11 以下”这个疑问到底怎么理解

很多人在网上搜索“C++11 以下能用 std::reverse 吗”，其实是被一些老的教程或编译器给误导了。std::reverse 从 C++98 标准开始就在 里，和 C++11 没有任何绑定关系。C++11 带来的新特性是 auto、lambda、范围 for 这些写法，但 reverse 本身从来不需要这些特性。

不过，为什么这个问题会被反复问出来？原因有两个。

第一，有些老的编译器，尤其是 C++98 年代的部分编译器，对模板的支持存在缺陷，或者标准库实现不完整。比如 VC6 时代的 STL 版本，有些算法函数行为不太标准，导致程序行为异常。这种环境下，与其依赖库函数，不如自己写一个简单的循环反转，反而更可控。

第二，C++11 之前没有统一的 auto 和范围 for，写起来确实繁琐。很多教程在讲 reverse 时，示例代码是 C++11 风格的，初学者看多了就会产生一种错觉，以为 reverse 依赖 C++11。

所以准确的说法是：只要你的编译器支持 C++98 标准库，std::reverse 就能用。但如果你维护的是特别老的代码库，或者刚接触嵌入式、老工具链环境，稳妥起见可以写一个手动反转函数，逻辑极简，不依赖任何库实现。

2.3 反向拷贝：reverse_copy 的签名和使用价值

标准库里和 reverse 配套的是 reverse_copy，签名同样很直观：

template<class InputIt, class OutputIt> OutputIt reverse_copy(InputIt first, InputIt last, OutputIt d_first);

它不会改动原区间，而是把反转后的元素依次写入从 d_first 开始的目标位置，返回值为最后写入位置的下一个迭代器。

实际使用中，需要先保证目标容器有足够的空间。如果你用 std::vector，可以先 resize，或者用 back_inserter 适配器：

std::vector<int> src = {1, 2, 3, 4, 5}; std::vector<int> dst; std::reverse_copy(src.begin(), src.end(), std::back_inserter(dst));

这样 dst 里得到的是 5、4、3、2、1，src 保持不变。类似场景在数据快照、日志倒序展示中很常见，值得养成“能不动原数据就不动”的习惯。

3. 实操：五类容器与场景的 reverse 用法

3.1 数组：指针就是迭代器

内置数组可以直接把数组名当作首迭代器，数组名加长度作为尾迭代器：

int arr[] = {1, 2, 3, 4, 5}; std::reverse(arr, arr + 5);

这里 arr 退化为指针，arr + 5 指向数组末尾的下一个位置，完全符合 [first, last) 的要求。结果 arr 变成 5、4、3、2、1。

一点要小心：不要写成 arr + sizeof(arr) / sizeof(arr[0]) - 1，那样会把 last 指向最后一个元素，导致反转范围少了一个元素。正确长度就是 arr + 5，也就是 arr + 元素个数。

3.2 vector 和 deque：begin 与 end 的组合

vector 是最常用的动态数组，反转写法几乎是固定句式：

std::vector<int> v = {10, 20, 30, 40}; std::reverse(v.begin(), v.end());

deque 也支持随机访问迭代器，写法完全一样。但要注意，deque 的迭代器是随机访问迭代器，不是普通指针，千万不要拿 &v[0] 和 &v[0] + v.size() 去替代 begin 和 end。deque 内部存储不是连续内存，这种写法会直接导致未定义行为，程序可能崩溃，也可能产生莫名其妙的结果。

3.3 字符串：string 反转和 C 风格字符串反转

std::string 直接支持 begin 和 end：

std::string s = "hello"; std::reverse(s.begin(), s.end()); // s 变成 "olleh"

如果想反转的是 const char* 常量字符串，那不行——常量字符串存在只读区，且类型是 const char*，不能修改。必须先拷到 char 数组或 std::string 里再操作：

const char* literal = "hello"; std::string s(literal); std::reverse(s.begin(), s.end());

如果是 char str[] 这种可写数组，可以用 strlen 取长度：

char str[] = "hello"; std::reverse(str, str + strlen(str));

这里需要包含 。同时注意，strlen 返回的是不含结尾 '\0' 的字符数，所以 str + strlen(str) 正好指向 '\0' 的位置，反转不会动这个结尾符。

3.4 list 容器：成员函数 reverse 与 std::reverse 的微妙区别

std::list 是双向链表，支持双向迭代器，理论上可以用 std::reverse：

std::list<int> lst = {1, 2, 3, 4}; std::reverse(lst.begin(), lst.end());

但 list 自己还有一个成员函数：

lst.reverse();

两者都能完成反转，但语义上略有差别。成员函数 reverse 是链表容器专门提供的操作，实现上只需要调整节点之间的链接指针，不改变节点本身的值；std::reverse 作为通用算法，则是通过迭代器交换元素值。对于 list 来说，std::reverse 在交换时要反复读写节点数据，而成员函数 reverse 只改指针，开销更小。

所以，处理 list 时优先用成员函数 lst.reverse()。这算是一个比较隐蔽的细节，网上不少示例喜欢统一用 std::reverse 处理所有容器，性能敏感场景下并不划算。

3.5 反向遍历：不改数据也能倒序看

有时候业务需求不是真的反转数据，而是希望倒着遍历一遍。这时候不必调用 reverse，直接用反向迭代器即可：

std::vector<int> v = {1, 2, 3, 4, 5}; for (auto it = v.rbegin(); it != v.rend(); ++it) { // 依次输出 5 4 3 2 1 }

rbegin 和 rend 是反向迭代器，从逻辑上把容器倒过来遍历，但底层数据没有任何改动。这个技巧在日志展示、最近消息列表这种场景下非常实用，避免了不必要的拷贝和修改。C++11 之后也可以用范围 for 加反向迭代器适配器，不过 C++11 以下的代码库就只能手写 rbegin 循环了。

4. 核心原理拆解：双向迭代器、交换逻辑与复杂度真相

4.1 std::reverse 内部到底怎么工作

标准库对 reverse 的实现不是魔法，本质就是一个循环交换。大致逻辑可以理解为：

while (first != last && first != --last) { std::iter_swap(first, last); ++first; }

last 一开始指向尾后位置，先自减，指向最后一个有效元素，然后和 first 交换；交换完 first 前进，last 已经指向新的最后一个有效元素，下次循环再自减。直到 first 和 last 相遇或者越过，整个过程结束。

正因为 reverse 内部依赖广义上的交换操作，所以容器元素的类型必须满足可交换的要求。对于内置类型自然没问题；对于自定义类型，通常需要有可用的拷贝构造和赋值，或者移动语义。C++11 之前移动语义不完善，交换大量元素时的成本会更高一些，这也是老代码里频繁反转大对象时需要考虑的问题。

4.2 复杂度为什么是 O(n) 而不是 O(n/2)

从交换次数看，reverse 只交换 n/2 次，很多人因此误以为复杂度是 O(n/2)。但大 O 表示法忽略常数系数，O(n/2) 就是 O(n)。所以标准说法是时间复杂度 O(n)。

空间复杂度是 O(1)，因为 reverse 是原地操作，不额外分配与元素个数相关的存储。这比“先拷贝一份再反转”的方案省内存，也是它适合处理大数据量的原因。

对于 list 的成员函数 reverse，时间复杂度同样是 O(n)，但它只是重新链接指针，交换的是节点指针而非元素值。如果元素本身很大，成员函数的实际开销通常会低于 std::reverse 的值交换方案。

4.3 迭代器类别决定你能否用 reverse

std::reverse 要求双向迭代器。这里展开解释一下迭代器类别，因为不少人在自定义容器或数据结构时踩过坑。

C++ 迭代器大致分五类：输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器。std::reverse 对迭代器能力的最低要求是“双向”，也就是能 ++ 也能 --。常见的 vector、deque、list、string 都满足。而 forward_list、std::istream_iterator 这类只支持单向移动的迭代器，无法用于 reverse。

判断一个迭代器是否满足条件，最直接的办法是查容器类型。数组和 vector 提供随机访问迭代器，list 提供双向迭代器，forward_list 只提供前向迭代器。如果硬把 forward_list 的迭代器传进 std::reverse，编译阶段就会报错，错误信息通常很抽象，出现一堆模板实例化相关的提示。看到这类报错时，先检查容器类型，比强行去读报错内容要快得多。

4.4 reverse 之后迭代器、引用、元素地址会发生什么

这是很多线上 bug 的来源。

std::reverse 本身不插入、不删除元素，底层只是交换元素值。因此，容器的迭代器、指针、引用不会因为 reverse 而失效，它们仍然指向原来的位置，只是那个位置上存储的元素变了。

举个例子：

std::vector<int> v = {1, 2, 3, 4, 5}; auto it = v.begin() + 1; // 指向 2 std::reverse(v.begin(), v.end()); // it 仍然指向 index 1，此时值是 4

如果业务代码在 reverse 之前把某个迭代器存了下来，reverse 之后又用它来读取旧值，取到的一定是新位置的元素，而不是之前那个值。这个“值跟随位置走”的特性，在实现缓存、索引表时很容易踩中。

5. 常见问题与排查技巧实录

5.1 忘了包含 ，报错信息却没提 reverse

新手最常遇到的问题：代码模板明明写对了，但编译报错显示 reverse 不是 std 的成员，或者提示找不到标识符。此时十有八九是没包含 。

有些编译器因为间接包含了其他头文件，可能碰巧也能编译通过，比如 在某些标准库实现中会间接引入 相关符号。但这是未定义行为，换个编译器或标准库版本就崩了。建议显式包含 ，不要依赖间接包含。

5.2 对常量字符串调用 reverse 导致崩溃

直接写：

const char* s = "hello"; std::reverse(s, s + 5);

这段代码在编译时往往能通过，因为 s 是 const char*，而 std::reverse 内部要交换元素，必然涉及写操作。写只读区内存，结果是运行时崩溃或段错误。排查时要用调试器看崩溃地址，往往指向字符串字面量所在的内存段。

正确做法是先把字符串复制到可写缓冲区或 std::string 中，再调用 reverse。

5.3 deque 的指针当迭代器用导致未定义行为

之前提到过，deque 的内存不是连续的。如果有人写：

std::deque<int> dq = {1, 2, 3}; std::reverse(&dq[0], &dq[0] + dq.size());

这是一段非常危险的代码。&dq[0] 只是第一个元素的地址，&dq[0] + dq.size() 在非连续内存中没有任何意义，可能指向完全无关的内存区域。程序可能立刻崩溃，也可能“恰好”工作了很长一段时间，然后在最不该出事的时候露出问题。

这个问题在 vector 上不会出现，因为 vector 保证连续存储。但别把 vector 的特性推广到所有容器，尤其是 deque。

5.4 reverse 空区间、单元素区间不会有问题吗

std::reverse 对空区间是安全的。如果 first == last，循环直接不执行，什么都不会发生。单元素区间也一样，first 自减后和自身交换，没有副作用。所以：不放心就加判空检查，但标准实现并不依赖这个检查。

真正需要注意的反而是：如果不小心把 last 传成了最后一个元素本身而不是尾后位置，那么最后一个元素永远不会参与反转。这种 bug 不会崩溃，但结果总是差一个，排查起来比较费劲。检查标准很简单——last 由 begin() + size() 构成，或者用 end()，永远不要用 end() - 1。

5.5 手写版本在旧标准下的替代方案

如果你确实需要兼容非常古老的编译环境，或者产品代码里限制不能依赖标准库算法，可以手写一个极简版本：

template<typename BidirIt> void my_reverse(BidirIt first, BidirIt last) { while (first != last && first != --last) { std::iter_swap(first, last); ++first; } }

这个实现不依赖 C++11 特性，C++98 编译器也能编译。但前提是你使用的标准库提供了 std::iter_swap；如果连这个都没有，就把交换逻辑拆成三行：

typename std::iterator_traits<BidirIt>::value_type tmp = *first; *first = *last; *last = tmp;

把这种写法当成一种兜底方案就好。能用标准库就用标准库，毕竟标准库的实现在各种边界条件上经过了充分验证，自己手写反而容易漏掉细节。

5.6 多字节字符串反转的隐患

C++ 的 std::string 反转是按 char 处理的。对于纯 ASCII 字符，没问题。但对于 UTF-8 编码的中文、emoji 等，一个字符可能占用多个字节，按字节反转会把多字节序列完全打乱，得到乱码。

比如 UTF-8 编码的“你好”，直接 reverse 后字节顺序全部颠倒，解码出来就是乱码。处理用户可见文本时，需要按 Unicode 码点或字形来反转，不能简单调用 std::reverse。通常的做法是先把 UTF-8 解码为 std::wstring 或其他 Unicode 表示，反转后再编码回去。

5.7 一句口诀总结排查思路

遇到 reverse 相关 bug，先问四个问题：包含 了吗？last 传的是尾后位置吗？容器允许双向迭代吗？内存可写吗？这四个问题排查完，绝大多数 reverse 的问题都能定位。

6. 扩展技巧：从 reverse 到反转数字、旋转数组和链表反转

6.1 整数反转：与 std::reverse 没直接关系但常被联想

很多人搜索 reverse，其实是想做整数反转。比如输入 12345，输出 54321。这类问题不能套用 std::reverse（它处理的是迭代器区间，不是数值的十进制位）。常见做法是循环取模和累加：

int reverseInt(int x) { long long result = 0; while (x != 0) { result = result * 10 + x % 10; x /= 10; } return result; }

这里用 long long 是为了防止中间结果溢出，面试中常考的溢出边界就在这个细节上。负数的情况要格外注意，最好先判断符号再处理绝对值，或者直接在循环里让 x % 10 保留负号，两种写法都行，但必须一致。

6.2 数组旋转和 reverse 的关系：三步反转法

有个经典技巧：把数组循环右移 k 位，可以用三次 reverse 完成。比如 [1, 2, 3, 4, 5] 右移两位，期望变成 [4, 5, 1, 2, 3]。

做法分三步：

• 整体反转：[5, 4, 3, 2, 1]
• 反转前 k 个元素：[4, 5, 3, 2, 1]
• 反转剩余元素：[4, 5, 1, 2, 3]

核心思路来自一个恒等式：将序列 AB 变换为 BA，可以先反转整体得到 reverse(B) reverse(A)，再分别反转两部分。这个“三段反转法”在很多算法题里都有变体，值得记一下。

注意 k 必须先对数组长度取模，否则 k 大于 n 时会越界或产生错误的移动。

6.3 反转链表：成员函数 reverse 和手写指针操作

链表的反转在面试题里非常高频。用 std::list 时，直接调用 lst.reverse() 就能完成，这不算算法题，面试官想看的是自己实现单链表的反转。

经典迭代写法：

struct Node { int val; Node* next; }; Node* reverseList(Node* head) { Node* prev = nullptr; Node* cur = head; while (cur) { Node* next = cur->next; cur->next = prev; prev = cur; cur = next; } return prev; }

这个写法的关键是先保存当前节点的下一个节点，再改当前节点的 next 指针，否则一旦修改了 next，原来的下一个节点就找不到了。实际写代码时，漏掉 next 临时变量是最常见的错误。

6.4 用 reverse_copy 生成倒序副本而不破坏原始数据

日志系统、报表服务里，经常需要把最新记录显示在最前面，但底层存储不能动。那时可以用 reverse_copy 生成一份临时倒序数据。如果只是遍历，用反向迭代器更省内存；如果后续还要多次随机访问倒序结果，再考虑 reverse_copy 到 vector。

把选择范围缩小一下：

• 只想倒着遍历一次：用 rbegin / rend。
• 需要一份完整的倒序数据，且原数据不能改：用 reverse_copy。
• 不介意修改原数据，且后续一直用倒序排列：用 std::reverse。

7. 一个速查表：十分钟掌握的 reverse 使用规范

把整篇内容浓缩成一张表，以后写代码随手可查。

最后分享一个我平时写代码的习惯：凡是涉及到 reverse 的代码，提交前我都会打印一遍反转前后的数据，肉眼确认边界。尤其是 last 到底是 end() 还是 end() - 1，这个只差一位的 bug 很难靠编译器和静态检查抓出来，但运行结果会一直错得莫名其妙。reverse 本身不难，难的是你永远不知道上一个调用它的人传进来的迭代器到底指向哪里。