std::views::join ​

什么是 views::join ​

std::views::join 是 C++20 Ranges 库中的适配器,用于将嵌套的范围(范围的范围)展平为一个单层范围。比如一个 vector<vector<int>> 经过 join 后变成一个连续的 int 序列。

cpp
auto flat = nested | std::views::join;

join 是惰性的——不会真正创建新容器,只是在迭代时依次遍历每个内层范围的元素。

基本示例 ​

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

// ============================
// 示例1:展平嵌套 vector
// ============================

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

    // 展平为单层序列
    auto flat = nested | std::views::join;

    std::cout << "展平: ";
    for (int v : flat) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5 6 7 8 9
}

// ============================
// 示例2:展平字符串数组
// ============================

void string_demo() {
    std::vector<std::string> words = {"Hello", " ", "World", "!"};

    // 每个 string 是一个字符范围,join 后变成字符序列
    auto chars = words | std::views::join;

    std::cout << "连接字符: ";
    for (char c : chars) std::cout << c;
    std::cout << std::endl;  // Hello World!
}

// ============================
// 示例3:与 transform 组合
// ============================

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

    // 把每个数字 n 变成 [1..n] 的序列,然后展平
    auto expanded = data
        | std::views::transform([](int n) {
            return std::views::iota(1, n + 1);
        })
        | std::views::join;

    std::cout << "展开: ";
    for (int v : expanded) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 1 2 3 4 5 1 2
}

// ============================
// 示例4:处理二维矩阵
// ============================

void matrix_demo() {
    // 3x3 矩阵
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 按行展平
    auto flat = matrix | std::views::join;

    // 求和
    int sum = 0;
    for (int v : flat) sum += v;
    std::cout << "矩阵元素之和: " << sum << std::endl;  // 45

    // 找最大值
    auto it = std::ranges::max_element(matrix | std::views::join);
    std::cout << "最大值: " << *it << std::endl;  // 9
}

// ============================
// 示例5:展平后过滤
// ============================

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

    // 展平后过滤偶数
    auto flat_evens = nested
        | std::views::join
        | std::views::filter([](int x) { return x % 2 == 0; });

    std::cout << "展平后的偶数: ";
    for (int v : flat_evens) std::cout << v << " ";
    std::cout << std::endl;  // 2 4 6 8 10 12
}

// ============================
// 示例6:空内层范围的处理
// ============================

void empty_inner_demo() {
    std::vector<std::vector<int>> nested = {
        {1, 2},
        {},          // 空范围——join 会自动跳过
        {3},
        {},
        {4, 5, 6}
    };

    auto flat = nested | std::views::join;

    std::cout << "包含空范围: ";
    for (int v : flat) std::cout << v << " ";
    std::cout << std::endl;  // 1 2 3 4 5 6
}

// ============================
// 示例7:split 与 join 的互逆关系
// ============================

void split_join_demo() {
    std::string csv = "Alice,Bob,Charlie,Diana";

    // split 按逗号分割
    auto parts = csv | std::views::split(',');

    std::cout << "分割后的部分:" << std::endl;
    for (auto part : parts) {
        std::cout << "  ";
        for (char c : part) std::cout << c;
        std::cout << std::endl;
    }

    // 注意:split 后 join 回来不会恢复分隔符
    // join 只是把子范围的元素依次连起来
    auto joined = csv | std::views::split(',') | std::views::join;

    std::cout << "join 后: ";
    for (char c : joined) std::cout << c;
    std::cout << std::endl;  // AliceBobCharlieDiana(没有逗号)
}

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

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

    std::cout << "\n=== transform + join ===" << std::endl;
    combo_demo();

    std::cout << "\n=== 二维矩阵 ===" << std::endl;
    matrix_demo();

    std::cout << "\n=== 展平后过滤 ===" << std::endl;
    filter_after_join_demo();

    std::cout << "\n=== 空内层范围 ===" << std::endl;
    empty_inner_demo();

    std::cout << "\n=== split + join ===" << std::endl;
    split_join_demo();

    return 0;
}

join_view 的范围类别 ​

外层范围内层范围join_view 类别
forward + 引用内层bidirectionalbidirectional
forward + 引用内层forwardforward
input任意input
任意非引用(prvalue)input

join_view 的类别取决于外层和内层范围的类别。如果内层范围是临时值(prvalue),join_view 最多只能是 input_range。

C++23 新增:join_with ​

C++23 新增了 std::views::join_with,允许在连接时插入分隔符:

cpp
// C++23
std::vector<std::string> words = {"Hello", "World"};
auto joined = words | std::views::join_with(' ');
// 结果: H e l l o   W o r l d(中间有空格)

适用场景 ​

  • 展平嵌套容器(如 vector<vector<int>>)
  • 连接字符串序列
  • 展开并处理二维矩阵
  • 与 transform 组合实现 flat_map 效果
  • 处理分层数据结构

常见问题 ​

join 会跳过空的内层范围吗?

会。空的内层范围会被自然跳过,不会产生任何元素。

join 后的视图是 sized_range 吗?

通常不是,因为展平后的总元素数不能 O(1) 计算。

join 和 flat_map 有什么关系?

transform | join 等价于其他语言中的 flat_map(先对每个元素做变换生成子范围,再展平)。

注意事项 ​

  • join 要求外层范围的元素本身也是范围
  • 如果内层范围是临时值(如 transform 返回的 iota_view),join_view 最多只能是 input_range
  • join 不会在子范围之间插入分隔符(需要的话用 C++23 的 join_with)
  • join_view 通常不是 sized_range

总结 ​

std::views::join 将嵌套的范围展平为单层范围,惰性地依次遍历每个内层范围的元素。它是处理嵌套数据结构的基本工具,配合 transform 可以实现 flat_map 的效果。空的内层范围会被自动跳过。join_view 的范围类别取决于外层和内层范围的类别和值类别。C++23 新增了 join_with 适配器,支持在连接时插入分隔符。