std::views::transform ​

什么是 views::transform ​

std::views::transform 是 C++20 Ranges 库中的核心适配器,它对范围中的每个元素应用一个变换函数,返回变换后结果组成的视图。变换是惰性的——只有在迭代时才对当前元素调用变换函数。

cpp
auto view = data | std::views::transform(fn);

transform_view 保留了底层范围的大部分能力(如果底层是 random_access_range,变换后仍然是 random_access_range),这和 filter_view 不同。

transform_view 的范围类别保留 ​

底层范围类别transform_view 的类别
random_access_rangerandom_access_range
bidirectional_rangebidirectional_range
forward_rangeforward_range
input_rangeinput_range
sized_rangesized_range(保留)

transform 不会像 filter 那样降级范围类别,因为变换是一对一映射——每个输入元素对应一个输出元素。

基本示例 ​

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

// ============================
// 示例1:基本变换
// ============================

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

    // 每个元素乘以 10
    auto scaled = data | std::views::transform([](int x) { return x * 10; });

    std::cout << "乘以10: ";
    for (int v : scaled) std::cout << v << " ";
    std::cout << std::endl;  // 10 20 30 40 50

    // 每个元素平方
    auto squared = data | std::views::transform([](int x) { return x * x; });

    std::cout << "平方: ";
    for (int v : squared) std::cout << v << " ";
    std::cout << std::endl;  // 1 4 9 16 25
}

// ============================
// 示例2:类型变换
// ============================

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

    // int → string 的变换
    auto as_strings = numbers
        | std::views::transform([](int x) { return std::to_string(x); });

    std::cout << "字符串: ";
    for (const auto& s : as_strings) std::cout << "\"" << s << "\" ";
    std::cout << std::endl;

    // int → double 的变换
    auto as_doubles = numbers
        | std::views::transform([](int x) { return x * 1.5; });

    std::cout << "浮点数: ";
    for (double d : as_doubles) std::cout << d << " ";
    std::cout << std::endl;  // 1.5 3 4.5 6 7.5

    // int → bool 的变换
    auto is_even = numbers
        | std::views::transform([](int x) { return x % 2 == 0; });

    std::cout << "偶数判断: " << std::boolalpha;
    for (bool b : is_even) std::cout << b << " ";
    std::cout << std::endl;
}

// ============================
// 示例3:结构体成员提取
// ============================

struct Student {
    std::string name;
    int age;
    double gpa;
};

void struct_demo() {
    std::vector<Student> students = {
        {"Alice", 20, 3.8},
        {"Bob", 22, 3.2},
        {"Charlie", 21, 3.9},
        {"Diana", 23, 3.5},
    };

    // 提取名字
    auto names = students
        | std::views::transform([](const Student& s) { return s.name; });

    std::cout << "名字: ";
    for (const auto& name : names) std::cout << name << " ";
    std::cout << std::endl;

    // 提取 GPA
    auto gpas = students
        | std::views::transform([](const Student& s) { return s.gpa; });

    std::cout << "GPA: ";
    for (double gpa : gpas) std::cout << gpa << " ";
    std::cout << std::endl;

    // 生成描述字符串
    auto descriptions = students
        | std::views::transform([](const Student& s) {
            return s.name + " (age " + std::to_string(s.age) + ")";
        });

    std::cout << "描述:" << std::endl;
    for (const auto& desc : descriptions) {
        std::cout << "  " << desc << std::endl;
    }
}

// ============================
// 示例4:与 filter 组合
// ============================

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

    // 先过滤再变换
    auto even_squares = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; });

    std::cout << "偶数的平方: ";
    for (int v : even_squares) std::cout << v << " ";
    std::cout << std::endl;  // 4 16 36 64 100

    // 先变换再过滤
    auto big_squares = data
        | std::views::transform([](int x) { return x * x; })
        | std::views::filter([](int x) { return x > 25; });

    std::cout << "大于25的平方数: ";
    for (int v : big_squares) std::cout << v << " ";
    std::cout << std::endl;  // 36 49 64 81 100
}

// ============================
// 示例5:多层 transform 嵌套
// ============================

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

    // 多次变换链式组合
    auto result = data
        | std::views::transform([](int x) { return x + 10; })     // +10
        | std::views::transform([](int x) { return x * 2; })      // *2
        | std::views::transform([](int x) { return x - 5; });     // -5

    // (1+10)*2-5=17, (2+10)*2-5=19, (3+10)*2-5=21, ...
    std::cout << "链式变换: ";
    for (int v : result) std::cout << v << " ";
    std::cout << std::endl;
}

// ============================
// 示例6:transform 保留随机访问能力
// ============================

void random_access_demo() {
    std::vector<int> data = {10, 20, 30, 40, 50};

    auto doubled = data | std::views::transform([](int x) { return x * 2; });

    // transform_view 保留了 random_access_range
    // 可以用下标访问
    std::cout << "doubled[0] = " << doubled[0] << std::endl;  // 20
    std::cout << "doubled[3] = " << doubled[3] << std::endl;  // 80

    // 可以获取大小
    std::cout << "大小: " << std::ranges::size(doubled) << std::endl;  // 5
}

// ============================
// 示例7:transform 与 iota 生成序列
// ============================

void generate_demo() {
    // 生成前10个平方数
    auto squares = std::views::iota(1, 11)
        | std::views::transform([](int x) { return x * x; });

    std::cout << "前10个平方数: ";
    for (int v : squares) std::cout << v << " ";
    std::cout << std::endl;

    // 生成 ASCII 码表的一部分
    auto chars = std::views::iota(65, 91)
        | std::views::transform([](int x) { return static_cast<char>(x); });

    std::cout << "大写字母: ";
    for (char c : chars) std::cout << c;
    std::cout << std::endl;
}

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

    std::cout << "\n=== 类型变换 ===" << std::endl;
    type_change_demo();

    std::cout << "\n=== 结构体成员 ===" << std::endl;
    struct_demo();

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

    std::cout << "\n=== 链式变换 ===" << std::endl;
    chain_transform_demo();

    std::cout << "\n=== 随机访问 ===" << std::endl;
    random_access_demo();

    std::cout << "\n=== 序列生成 ===" << std::endl;
    generate_demo();

    return 0;
}

views::transform vs std::ranges::transform ​

特性views::transform(适配器)ranges::transform(算法)
返回类型视图(惰性)输出迭代器
求值方式惰性——迭代时计算即时——立刻计算全部
需要输出范围不需要需要
管道支持支持 ``
内存分配零需要预分配输出空间
用途数据处理管道直接写入输出容器

适用场景 ​

  • 对集合中的每个元素做映射变换
  • 提取结构体/类的某个成员
  • 类型转换(int → string 等)
  • 数学计算(平方、缩放、归一化等)
  • 与 filter 组合做过滤-变换管道
  • 惰性生成序列

常见问题 ​

transform 返回的是引用还是值?

取决于变换函数的返回类型。如果函数返回值类型(如 int),迭代器解引用得到的就是值。如果返回引用(如 int&),得到的就是引用。

transform_view 可以用下标访问吗?

如果底层范围是 random_access_range,transform_view 也是 random_access_range,可以用 [] 下标访问。

多层 transform 嵌套会有性能问题吗?

通常不会。编译器会把多层视图的操作内联成一次遍历,生成的代码和手写单循环类似。

注意事项 ​

  • transform_view 不缓存结果——多次迭代会多次调用变换函数
  • 变换函数应该是无副作用的纯函数
  • transform 保留底层范围的类别(不像 filter 会降级)
  • transform 保留 sized_range 属性
  • 变换函数的返回类型决定了视图的元素类型

总结 ​

std::views::transform 对范围中的每个元素应用变换函数,返回变换结果组成的惰性视图。和 filter 不同,transform 保留了底层范围的所有能力——如果底层是 random_access_range,变换后仍然是 random_access_range,仍然支持下标访问和 O(1) 获取大小。变换是一对一的映射,不改变元素个数。它是 Ranges 管道中最常用的适配器之一,常与 filter、take 等组合使用。