std::views::reverse ​

什么是 views::reverse ​

std::views::reverse 是 C++20 Ranges 库中的适配器,它返回底层范围的逆序视图。元素的迭代顺序反转,但不会移动或复制任何元素——reverse_view 只是从后向前遍历底层范围的迭代器。

底层范围必须是 bidirectional_range(可以双向遍历),因为逆序迭代需要从 end 往 begin 方向走。

cpp
auto reversed = data | std::views::reverse;

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <string>
#include <ranges>
#include <list>
#include <algorithm>

// ============================
// 示例1:基本逆序
// ============================

void basic_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5};

    // 逆序视图
    auto reversed = data | std::views::reverse;

    std::cout << "逆序: ";
    for (int v : reversed) std::cout << v << " ";
    std::cout << std::endl;  // 5 4 3 2 1

    // 原始数据不受影响
    std::cout << "原始: ";
    for (int v : data) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5
}

// ============================
// 示例2:字符串逆序
// ============================

void string_demo() {
    std::string text = "Hello, World!";

    // 逆序字符
    auto reversed = text | std::views::reverse;

    std::cout << "逆序字符串: ";
    for (char c : reversed) std::cout << c;
    std::cout << std::endl;  // !dlroW ,olleH

    // 判断回文
    auto is_palindrome = [](const std::string& s) {
        auto reversed = s | std::views::reverse;
        return std::ranges::equal(s, reversed);
    };

    std::cout << "abcba 是回文: " << std::boolalpha
              << is_palindrome("abcba") << std::endl;   // true
    std::cout << "hello 是回文: " << std::boolalpha
              << is_palindrome("hello") << std::endl;    // false
}

// ============================
// 示例3:与其他适配器组合
// ============================

void combo_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 取最后 3 个元素(逆序后取前 3 个再逆序回来)
    auto last_three = data
        | std::views::reverse
        | std::views::take(3)
        | std::views::reverse;

    std::cout << "最后3个: ";
    for (int v : last_three) std::cout << v << " ";
    std::cout << std::endl;  // 8 9 10

    // 过滤偶数后逆序
    auto reversed_evens = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::reverse;

    std::cout << "偶数逆序: ";
    for (int v : reversed_evens) std::cout << v << " ";
    std::cout << std::endl;  // 10 8 6 4 2
}

// ============================
// 示例4:通过逆序视图修改元素
// ============================

void modify_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5};

    // 通过逆序视图修改——修改的是原始数据
    auto reversed = data | std::views::reverse;
    *std::ranges::begin(reversed) = 100;  // 修改逆序的第一个元素(原始的最后一个)

    std::cout << "修改后: ";
    for (int v : data) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 100
}

// ============================
// 示例5:双重逆序消除
// ============================

void double_reverse_demo() {
    std::vector<int> data = {1, 2, 3, 4, 5};

    // 两次 reverse 会被编译器优化——直接返回原始范围的视图
    auto double_reversed = data
        | std::views::reverse
        | std::views::reverse;

    std::cout << "双重逆序: ";
    for (int v : double_reversed) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5(和原始一样)
}

// ============================
// 示例6:list 也可以逆序
// ============================

void list_demo() {
    std::list<int> lst = {10, 20, 30, 40, 50};

    // list 是 bidirectional_range,可以使用 reverse
    auto reversed = lst | std::views::reverse;

    std::cout << "list 逆序: ";
    for (int v : reversed) std::cout << v << " ";
    std::cout << std::endl;  // 50 40 30 20 10
}

// ============================
// 示例7:逆序遍历 map
// ============================

void map_demo() {
    std::map<std::string, int> scores = {
        {"Alice", 95}, {"Bob", 82}, {"Charlie", 78}
    };

    // map 是 bidirectional_range,可以逆序遍历
    auto reversed = scores | std::views::reverse;

    std::cout << "map 逆序:" << std::endl;
    for (const auto& [name, score] : reversed) {
        std::cout << "  " << name << ": " << score << std::endl;
    }
}

int main() {
    std::cout << "=== 基本逆序 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 字符串 ===" << std::endl;
    string_demo();

    std::cout << "\n=== 组合 ===" << std::endl;
    combo_demo();

    std::cout << "\n=== 修改元素 ===" << std::endl;
    modify_demo();

    std::cout << "\n=== 双重逆序 ===" << std::endl;
    double_reverse_demo();

    std::cout << "\n=== list ===" << std::endl;
    list_demo();

    std::cout << "\n=== map ===" << std::endl;
    map_demo();

    return 0;
}

reverse_view 的范围类别 ​

底层范围类别reverse_view 的类别
contiguous_rangerandom_access_range(降一级)
random_access_rangerandom_access_range
bidirectional_rangebidirectional_range
forward_range不支持(编译错误)
input_range不支持(编译错误)

reverse_view 要求底层范围至少是 bidirectional_range。

适用场景 ​

  • 逆序遍历容器而不修改原始数据
  • 取最后 n 个元素(reverse + take + reverse)
  • 回文检测
  • 从后向前搜索
  • 与 filter/transform 组合后逆序输出

常见问题 ​

reverse 会复制数据吗?

不会。reverse_view 只是改变了迭代方向,内部使用反向迭代器遍历底层范围。

两次 reverse 会被优化掉吗?

是的。标准规定对 reverse_view 再次 reverse 会直接返回底层范围的视图,不会嵌套两层。

forward_list 可以用 reverse 吗?

不可以。forward_list 是 forward_range(只能单向遍历),不满足 reverse 要求的 bidirectional_range。

注意事项 ​

  • 底层范围必须是 bidirectional_range
  • reverse_view 不复制数据,是零开销的视图
  • 双重 reverse 会被标准库自动消除
  • reverse_view 保持 sized_range 属性
  • 通过 reverse_view 的迭代器修改会影响原始数据

总结 ​

std::views::reverse 提供了对范围的零开销逆序访问,不复制或移动任何元素,只是改变了迭代方向。它要求底层范围至少是 bidirectional_range。标准库会自动消除双重 reverse。reverse 常和 take 组合来获取范围末尾的元素,也可以用于回文检测、逆序搜索等场景。