std::ranges::to 容器转换(C++23) ​

什么是 ranges::to ​

C++23 引入了 std::ranges::to,解决了一个长期存在的痛点:视图管道的结果是惰性的视图,没有简单的方法直接转换为容器。ranges::to 允许将任何范围(包括视图管道的结果)直接转换为指定的容器类型。

cpp
// 视图管道的结果直接转换为 vector
auto vec = std::views::iota(1, 10)
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::ranges::to<std::vector>();

C++23 之前 vs 之后 ​

操作C++23 之前C++23
视图转 vector手动构造 vector(view.begin(), view.end())view | ranges::to<vector>()
视图转 setset(view.begin(), view.end())view | ranges::to<set>()
视图转 string手动拼接view | ranges::to<string>()
嵌套视图转嵌套容器很繁琐ranges::to 递归转换

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <string>
#include <ranges>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <algorithm>

// ============================
// 示例1:视图管道转 vector
// ============================

void basic_demo() {
    // 管道结果直接转 vector
    auto squares = std::views::iota(1, 11)
        | std::views::transform([](int x) { return x * x; })
        | std::ranges::to<std::vector>();

    // squares 的类型是 std::vector<int>
    std::cout << "平方数: ";
    for (int v : squares) std::cout << v << " ";
    std::cout << std::endl;

    // 过滤后转 vector
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto evens = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::ranges::to<std::vector>();

    std::cout << "偶数 vector: ";
    for (int v : evens) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例2:转换为不同容器类型
// ============================

void different_containers_demo() {
    auto numbers = std::views::iota(1, 6);

    // 转为 vector
    auto vec = numbers | std::ranges::to<std::vector>();

    // 转为 list
    auto lst = numbers | std::ranges::to<std::list>();

    // 转为 deque
    auto deq = numbers | std::ranges::to<std::deque>();

    // 转为 set(自动去重排序)
    std::vector<int> with_dups = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
    auto unique_set = with_dups
        | std::ranges::to<std::set>();

    std::cout << "set(去重排序): ";
    for (int v : unique_set) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5 6 9
}

// ============================
// 示例3:类型推导(不指定元素类型)
// ============================

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

    // 不指定元素类型——自动推导
    auto vec = data
        | std::views::transform([](int x) { return x * 1.5; })
        | std::ranges::to<std::vector>();
    // vec 的类型是 vector<double>

    std::cout << "推导为 double: ";
    for (double v : vec) std::cout << v << " ";
    std::cout << std::endl;

    // 也可以显式指定完整类型
    auto vec2 = data
        | std::views::transform([](int x) { return x * 1.5; })
        | std::ranges::to<std::vector<float>>();
    // vec2 的类型是 vector<float>
}

// ============================
// 示例4:转换为 string
// ============================

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

    // 过滤掉非字母字符,转为新字符串
    auto letters_only = text
        | std::views::filter([](char c) { return std::isalpha(c); })
        | std::ranges::to<std::string>();

    std::cout << "只保留字母: " << letters_only << std::endl;  // HelloWorld

    // 转大写
    auto upper = text
        | std::views::transform([](char c) { return static_cast<char>(std::toupper(c)); })
        | std::ranges::to<std::string>();

    std::cout << "大写: " << upper << std::endl;  // HELLO, WORLD!
}

// ============================
// 示例5:转换为 map
// ============================

void map_demo() {
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

    // 用 zip + to 创建 map
    auto ids = std::views::iota(1);
    auto name_map = std::views::zip(ids, names)
        | std::views::transform([](auto pair) {
            auto [id, name] = pair;
            return std::pair{id, name};
        })
        | std::ranges::to<std::map>();

    for (const auto& [id, name] : name_map) {
        std::cout << id << " -> " << name << std::endl;
    }
}

// ============================
// 示例6:嵌套范围转换
// ============================

void nested_demo() {
    // 嵌套视图转嵌套容器
    auto matrix = std::views::iota(0, 3)
        | std::views::transform([](int row) {
            return std::views::iota(row * 3 + 1, row * 3 + 4)
                | std::ranges::to<std::vector>();
        })
        | std::ranges::to<std::vector>();

    // matrix 的类型是 vector<vector<int>>
    for (const auto& row : matrix) {
        for (int v : row) std::cout << v << " ";
        std::cout << std::endl;
    }
    // 1 2 3
    // 4 5 6
    // 7 8 9
}

// ============================
// 示例7:带额外参数的构造
// ============================

void extra_args_demo() {
    auto numbers = std::views::iota(1, 6);

    // 传递额外的分配器参数(这里用默认分配器举例)
    auto vec = numbers | std::ranges::to<std::vector<int>>(std::allocator<int>{});

    std::cout << "带分配器: ";
    for (int v : vec) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例8:from_range 构造函数
// ============================

void from_range_demo() {
    auto view = std::views::iota(1, 6)
        | std::views::transform([](int x) { return x * 10; });

    // 用 from_range_t 标签直接构造容器
    std::vector<int> vec(std::from_range, view);

    std::cout << "from_range 构造: ";
    for (int v : vec) std::cout << v << " ";
    std::cout << std::endl;  // 10 20 30 40 50
}

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

    std::cout << "\n=== 不同容器 ===" << std::endl;
    different_containers_demo();

    std::cout << "\n=== 类型推导 ===" << std::endl;
    deduction_demo();

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

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

    std::cout << "\n=== 嵌套 ===" << std::endl;
    nested_demo();

    std::cout << "\n=== from_range ===" << std::endl;
    from_range_demo();

    return 0;
}

ranges::to 的两种调用方式 ​

cpp
// 方式1:管道语法(推荐)
auto vec = view | std::ranges::to<std::vector>();

// 方式2:函数调用语法
auto vec = std::ranges::to<std::vector>(view);

注意管道语法中 to<std::vector>() 的括号是必须的。

ranges::to 的构造策略 ​

ranges::to 按以下优先级尝试构造容器:

优先级策略说明
最高直接构造C(range, args...)
次高from_range 构造C(from_range, range, args...)
次低迭代器对构造C(range.begin(), range.end(), args...)
最低默认构造 + push_back先构造空容器,再逐个插入

适用场景 ​

  • 视图管道的结果物化为容器
  • 范围类型之间的转换(如 list 转 vector)
  • 过滤/变换后直接创建新容器
  • 创建 set/map 从序列容器
  • 嵌套视图转嵌套容器

常见问题 ​

ranges::to 和直接用构造函数有什么区别?

ranges::to 支持管道语法,可以直接接在视图管道后面。它还支持类型推导——不需要指定元素类型。此外,如果源范围是 sized_range,ranges::to 会先 reserve 再插入,避免多次扩容。

ranges::to 会自动推导元素类型吗?

会。ranges::to<std::vector>() 会根据范围的元素类型自动推导 vector 的模板参数。你也可以显式指定完整类型 ranges::to<std::vector<double>>()。

from_range_t 构造函数是什么?

C++23 为所有标准容器添加了接受 std::from_range_t 标签的构造函数,可以直接从范围构造容器。ranges::to 内部会优先使用这个构造函数。

注意事项 ​

  • 管道语法中 to<vector>() 的括号不能省略
  • ranges::to 对 sized_range 会预分配空间(调用 reserve)
  • 目标类型不能是视图类型(必须是容器)
  • 嵌套范围会递归转换
  • 可以传递额外的构造参数(如分配器)

编译器支持情况 ​

编译器ranges::to最低版本
GCC支持14.0
Clang支持17.0
MSVC支持19.34 (VS 2022 17.4)

总结 ​

std::ranges::to 是 C++23 中补全 Ranges 库最后一块拼图的特性。C++20 的视图管道可以惰性地描述数据处理流程,但没有简单的方法把结果存到容器中。ranges::to 让管道可以自然地以 | ranges::to<vector>() 结尾,将惰性视图物化为实际的容器。它支持类型推导、多种构造策略、嵌套转换,还会对 sized_range 预分配空间以提升性能。配合 C++23 容器新增的 from_range 构造函数,范围和容器之间的转换变得非常流畅。