std::views::zip(C++23) ​

什么是 views::zip ​

std::views::zip 是 C++23 引入的范围适配器,它将多个范围"拉链式"组合在一起,生成一个元素为 tuple 的视图。第 i 个元素是各输入范围第 i 个元素组成的 tuple。结果视图的长度等于最短输入范围的长度。

cpp
auto zipped = std::views::zip(range1, range2, range3);
// 每个元素是 std::tuple<T1&, T2&, T3&>

这类似于 Python 的 zip() 函数。

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <string>
#include <ranges>
#include <array>
#include <list>
#include <tuple>
#include <algorithm>
#include <numeric>

// ============================
// 示例1:基本 zip
// ============================

void basic_demo() {
    std::vector<int> ids = {1, 2, 3, 4};
    std::vector<std::string> names = {"Alice", "Bob", "Charlie", "Diana"};

    // zip 两个范围
    auto zipped = std::views::zip(ids, names);

    for (auto [id, name] : zipped) {
        std::cout << id << ": " << name << std::endl;
    }
}

// ============================
// 示例2:三个范围 zip
// ============================

void triple_zip_demo() {
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    std::vector<int> ages = {20, 22, 21};
    std::vector<double> gpas = {3.8, 3.2, 3.9};

    // zip 三个范围
    for (auto [name, age, gpa] : std::views::zip(names, ages, gpas)) {
        std::cout << name << " 年龄:" << age
                  << " GPA:" << gpa << std::endl;
    }
}

// ============================
// 示例3:不等长范围——取最短
// ============================

void unequal_demo() {
    std::vector<int> v1 = {1, 2, 3, 4, 5};
    std::vector<char> v2 = {'a', 'b', 'c'};  // 只有 3 个元素

    // 结果长度为 min(5, 3) = 3
    auto zipped = std::views::zip(v1, v2);

    std::cout << "不等长 zip: ";
    for (auto [num, ch] : zipped) {
        std::cout << "(" << num << "," << ch << ") ";
    }
    std::cout << std::endl;  // (1,a) (2,b) (3,c)
}

// ============================
// 示例4:通过 zip 修改元素
// ============================

void modify_demo() {
    std::vector<int> prices = {100, 200, 300};
    std::vector<int> quantities = {5, 3, 8};

    // zip 返回引用——可以修改原始数据
    for (auto [price, qty] : std::views::zip(prices, quantities)) {
        price *= 2;   // 修改原始 prices
        qty += 10;    // 修改原始 quantities
    }

    std::cout << "修改后价格: ";
    for (int p : prices) std::cout << p << " ";
    std::cout << std::endl;  // 200 400 600

    std::cout << "修改后数量: ";
    for (int q : quantities) std::cout << q << " ";
    std::cout << std::endl;  // 15 13 18
}

// ============================
// 示例5:zip 与 enumerate 效果
// ============================

void enumerate_demo() {
    std::vector<std::string> fruits = {"apple", "banana", "cherry"};

    // 用 iota + zip 模拟 enumerate
    auto indexed = std::views::zip(std::views::iota(0), fruits);

    for (auto [i, fruit] : indexed) {
        std::cout << "[" << i << "] " << fruit << std::endl;
    }
}

// ============================
// 示例6:zip 与管道组合
// ============================

void pipeline_demo() {
    std::vector<int> x = {1, 2, 3, 4, 5};
    std::vector<int> y = {10, 20, 30, 40, 50};

    // zip 后用 transform 计算两个向量的逐元素之和
    auto sums = std::views::zip(x, y)
        | std::views::transform([](auto pair) {
            auto [a, b] = pair;
            return a + b;
        });

    std::cout << "逐元素之和: ";
    for (int v : sums) std::cout << v << " ";
    std::cout << std::endl;  // 11 22 33 44 55

    // zip + filter:找出 x[i] > y[i] 的位置
    auto x_greater = std::views::zip(x, y)
        | std::views::filter([](auto pair) {
            auto [a, b] = pair;
            return a > b;
        });

    // 本例中 x 的所有元素都小于 y 的对应元素,所以结果为空
}

// ============================
// 示例7:zip_transform
// ============================

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

    // zip_transform:zip + transform 的快捷方式
    auto products = std::views::zip_transform(
        [](int x, int y) { return x * y; },  // 变换函数
        a, b                                   // 输入范围
    );

    std::cout << "逐元素之积: ";
    for (int v : products) std::cout << v << " ";
    std::cout << std::endl;  // 4 10 18
}

// ============================
// 示例8:不同容器类型 zip
// ============================

void mixed_containers_demo() {
    std::vector<int> vec = {1, 2, 3};
    std::list<double> lst = {1.1, 2.2, 3.3};
    std::array<char, 3> arr = {'x', 'y', 'z'};

    // 不同容器类型可以 zip
    for (auto [v, l, a] : std::views::zip(vec, lst, arr)) {
        std::cout << v << " " << l << " " << a << std::endl;
    }
}

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

    std::cout << "\n=== 三范围 zip ===" << std::endl;
    triple_zip_demo();

    std::cout << "\n=== 不等长 ===" << std::endl;
    unequal_demo();

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

    std::cout << "\n=== enumerate 效果 ===" << std::endl;
    enumerate_demo();

    std::cout << "\n=== 管道组合 ===" << std::endl;
    pipeline_demo();

    std::cout << "\n=== zip_transform ===" << std::endl;
    zip_transform_demo();

    std::cout << "\n=== 混合容器 ===" << std::endl;
    mixed_containers_demo();

    return 0;
}

zip 相关适配器一览 ​

适配器说明版本
views::zip(r1, r2, ...)多个范围组合为 tuple 视图C++23
views::zip_transform(fn, r1, r2, ...)zip 后直接变换C++23
views::enumerate(r)等价于 zip(iota(0), r)C++23
views::adjacent<N>(r)滑动窗口(相邻 N 个元素)C++23
views::adjacent_transform<N>(r, fn)滑动窗口 + 变换C++23
views::pairwise(r)adjacent<2> 的别名C++23

适用场景 ​

  • 同时遍历多个相关联的数据序列
  • 将索引与数据配对(模拟 enumerate)
  • 逐元素计算两个向量的和/差/积
  • 比较两个序列的对应元素
  • 用结构化绑定解包 tuple 元素

常见问题 ​

zip 的元素类型是什么?

zip 返回的元素类型是 std::tuple<T1&, T2&, ...>,其中 T1、T2 是各输入范围的引用类型。因为是引用,所以可以通过 zip 视图修改原始数据。

多个范围长度不同会怎样?

zip 视图的长度等于最短输入范围的长度。超出部分被忽略。

zip_transform 和 zip + transform 有什么区别?

语义相同,但 zip_transform 更简洁,而且可能有更好的编译器优化,因为它避免了创建中间的 tuple。

zip 可以和 sort 配合使用吗?

zip_view 是 random_access_range(当所有输入都是 random_access_range 时),理论上可以配合 sort 使用,但需要注意 swap 语义。

注意事项 ​

  • zip 要求所有输入范围都是 view 或 viewable_range
  • zip 返回的元素是引用的 tuple,修改会影响原始数据
  • 长度取最短范围
  • zip 一个空的参数包(无参数)返回 empty_view<tuple<>>
  • zip_view 的范围类别是所有输入范围类别的最低公共类别

编译器支持情况 ​

编译器views::zip最低版本
GCC支持13.0
Clang支持16.0
MSVC支持19.34 (VS 2022 17.4)

总结 ​

std::views::zip 是 C++23 引入的重要范围适配器,用于将多个范围"拉链式"配对,生成 tuple 元素的视图。它类似于 Python 的 zip 函数,长度取最短范围。zip 返回的是引用 tuple,可以通过它修改原始数据。配合结构化绑定使用时代码非常简洁。zip_transform 是 zip + transform 的快捷方式,避免了中间 tuple 的创建。C++23 还引入了 enumerate、adjacent、pairwise 等相关适配器。