std::views::chunk 与 std::views::slide(C++23) ​

什么是 chunk 和 slide ​

C++23 引入了两个用于分组的范围适配器:

  • views::chunk(n):将范围按固定大小 n 分成不重叠的块。最后一块可能不足 n 个元素。
  • views::slide(n):生成大小为 n 的滑动窗口视图。每个窗口和下一个窗口重叠 n-1 个元素。
原始数据: [1, 2, 3, 4, 5, 6, 7, 8]

chunk(3):  [1,2,3] [4,5,6] [7,8]          -- 不重叠,最后一块可能不满
slide(3):  [1,2,3] [2,3,4] [3,4,5] [4,5,6] [5,6,7] [6,7,8]  -- 滑动窗口

chunk vs slide 对比 ​

特性chunk(n)slide(n)
分组方式不重叠的连续块重叠的滑动窗口
最后一组大小可能不足 n每组都是 n
结果组数ceil(size / n)size - n + 1
底层范围要求input_rangeforward_range
典型用途分页、批处理移动平均、相邻比较

基本示例 ​

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

// 辅助函数:打印子范围
void print_subrange(auto&& r) {
    std::cout << "[";
    bool first = true;
    for (auto v : r) {
        if (!first) std::cout << ", ";
        std::cout << v;
        first = false;
    }
    std::cout << "]";
}

// ============================
// 示例1:chunk 基本用法
// ============================

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

    std::cout << "chunk(3): ";
    for (auto chunk : data | std::views::chunk(3)) {
        print_subrange(chunk);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 2, 3] [4, 5, 6] [7, 8]

    std::cout << "chunk(4): ";
    for (auto chunk : data | std::views::chunk(4)) {
        print_subrange(chunk);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 2, 3, 4] [5, 6, 7, 8]

    std::cout << "chunk(5): ";
    for (auto chunk : data | std::views::chunk(5)) {
        print_subrange(chunk);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 2, 3, 4, 5] [6, 7, 8]
}

// ============================
// 示例2:slide 基本用法
// ============================

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

    std::cout << "slide(3): ";
    for (auto window : data | std::views::slide(3)) {
        print_subrange(window);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 2, 3] [2, 3, 4] [3, 4, 5] [4, 5, 6]

    std::cout << "slide(2): ";
    for (auto window : data | std::views::slide(2)) {
        print_subrange(window);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 2] [2, 3] [3, 4] [4, 5] [5, 6]
}

// ============================
// 示例3:chunk 实现分页
// ============================

void pagination_demo() {
    std::vector<std::string> items = {
        "A", "B", "C", "D", "E", "F", "G", "H", "I", "J"
    };

    int page_size = 3;
    int page_num = 0;

    // 用 chunk 实现分页
    for (auto page : items | std::views::chunk(page_size)) {
        std::cout << "第 " << ++page_num << " 页: ";
        for (const auto& item : page) {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }
    // 第 1 页: A B C
    // 第 2 页: D E F
    // 第 3 页: G H I
    // 第 4 页: J
}

// ============================
// 示例4:slide 实现移动平均
// ============================

void moving_average_demo() {
    std::vector<double> prices = {100.0, 102.5, 98.0, 105.0, 103.5, 107.0, 110.0};

    int window_size = 3;

    std::cout << "3日移动平均: ";
    for (auto window : prices | std::views::slide(window_size)) {
        // 计算窗口内的平均值
        double sum = 0.0;
        int count = 0;
        for (double v : window) {
            sum += v;
            count++;
        }
        double avg = sum / count;
        std::cout << avg << " ";
    }
    std::cout << std::endl;
    // 约: 100.167 101.833 102.167 105.167 106.833
}

// ============================
// 示例5:slide 检测相邻元素关系
// ============================

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

    // 用 slide(2) 检查相邻元素是否递增
    std::cout << "相邻递增检查:" << std::endl;
    for (auto pair : data | std::views::slide(2)) {
        auto it = std::ranges::begin(pair);
        int a = *it;
        int b = *(++it);
        std::cout << "  " << a << " → " << b
                  << (a < b ? " 递增" : " 非递增") << std::endl;
    }
}

// ============================
// 示例6:chunk_by 按条件分组
// ============================

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

    // chunk_by:相等的元素分为一组
    std::cout << "chunk_by(相等): ";
    for (auto group : data | std::views::chunk_by(std::equal_to{})) {
        print_subrange(group);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 1] [2] [3, 3, 3] [4] [5, 5]

    // chunk_by:递增序列分组
    std::cout << "chunk_by(递增): ";
    for (auto group : data | std::views::chunk_by(std::less{})) {
        print_subrange(group);
        std::cout << " ";
    }
    std::cout << std::endl;
    // [1, 1] 处断开因为 1 不小于 1
}

// ============================
// 示例7:chunk 与 transform 组合
// ============================

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

    // 每 3 个元素一组,计算每组的和
    auto group_sums = data
        | std::views::chunk(3)
        | std::views::transform([](auto chunk) {
            int sum = 0;
            for (int v : chunk) sum += v;
            return sum;
        });

    std::cout << "每组之和: ";
    for (int s : group_sums) std::cout << s << " ";
    std::cout << std::endl;
    // 6 15 24(1+2+3, 4+5+6, 7+8+9)
}

// ============================
// 示例8:stride 步进视图
// ============================

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

    // stride(3):每隔 3 个取一个
    auto stepped = data | std::views::stride(3);

    std::cout << "stride(3): ";
    for (int v : stepped) std::cout << v << " ";
    std::cout << std::endl;
    // 1 4 7 10
}

int main() {
    std::cout << "=== chunk ===" << std::endl;
    chunk_demo();

    std::cout << "\n=== slide ===" << std::endl;
    slide_demo();

    std::cout << "\n=== 分页 ===" << std::endl;
    pagination_demo();

    std::cout << "\n=== 移动平均 ===" << std::endl;
    moving_average_demo();

    std::cout << "\n=== 相邻检查 ===" << std::endl;
    adjacent_check_demo();

    std::cout << "\n=== chunk_by ===" << std::endl;
    chunk_by_demo();

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

    std::cout << "\n=== stride ===" << std::endl;
    stride_demo();

    return 0;
}

C++23 分组相关适配器一览 ​

适配器说明窗口大小重叠
views::chunk(n)固定大小不重叠分块运行时无
views::slide(n)固定大小滑动窗口运行时n-1
views::chunk_by(pred)按谓词分组动态无
views::stride(n)每隔 n 个取一个N/AN/A
views::adjacent<N>编译期大小滑动窗口编译期N-1
views::pairwiseadjacent<2> 的别名21

适用场景 ​

  • chunk:分页显示、批量处理、数据分组
  • slide:移动平均、相邻元素比较、信号处理中的滑动窗口
  • chunk_by:按条件分组(如连续相同值、连续递增序列)
  • stride:降采样、间隔取值

常见问题 ​

chunk 最后一块不足 n 个怎么办?

最后一块会包含剩余的所有元素,大小可能小于 n。这是正常行为。

slide 和 adjacent 有什么区别?

slide(n) 的 n 是运行时参数,adjacent<N> 的 N 是编译期常量。adjacent<N> 返回的元素是 tuple 而不是子范围,因为编译期知道窗口大小。

chunk_by 的谓词作用在哪里?

谓词作用在相邻的两个元素上。当谓词返回 false 时,在这两个元素之间分割。

n 为 0 或负数会怎样?

n 必须是正整数。传入 0 是未定义行为。

注意事项 ​

  • chunk 要求底层范围至少是 input_range
  • slide 要求底层范围至少是 forward_range
  • chunk 的最后一块可能不足 n 个元素
  • slide 的每个窗口大小固定为 n
  • chunk_by 的谓词应该是无副作用的
  • stride 的步长必须是正整数

编译器支持情况 ​

编译器chunk/slide/chunk_by/stride最低版本
GCC支持13.0
Clang支持17.0
MSVC支持19.34 (VS 2022 17.4)

总结 ​

C++23 引入了一组分组范围适配器:chunk 将范围切成不重叠的固定大小块,slide 生成重叠的滑动窗口,chunk_by 根据相邻元素的谓词动态分组,stride 按固定步长间隔取元素。这些适配器覆盖了常见的数据分组和窗口处理需求——分页用 chunk,移动平均用 slide,连续相同值分组用 chunk_by,降采样用 stride。所有适配器都是惰性的,不分配额外内存。