惰性求值机制 ​

什么是惰性求值 ​

惰性求值(Lazy Evaluation)是 C++20 Ranges 视图的核心特性。和传统的即时求值(创建视图时立刻处理所有元素)不同,惰性求值在创建视图时不做任何计算,只有在迭代到某个元素时才对该元素执行操作。

cpp
auto view = data
    | std::views::filter(pred)     // 不做任何计算
    | std::views::transform(fn);   // 仍然不做任何计算

for (auto v : view) {              // 这里才真正开始计算
    // 每次循环迭代一个元素
}

惰性求值 vs 即时求值 ​

特性惰性求值(视图)即时求值(传统算法)
何时计算迭代时,逐个元素调用时,全部元素
中间容器不需要每步可能需要
内存分配零(通常)可能多次分配
短路能力有(如 take 可以提前停止)无(处理全部元素)
无限序列支持(配合 take)不支持
多次遍历每次重新计算结果已缓存
适合场景只需要部分结果、管道组合需要多次访问结果

基本示例 ​

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

// ============================
// 示例1:惰性求值的直观证明
// ============================

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

    int filter_calls = 0;
    int transform_calls = 0;

    // 创建视图——此时 lambda 没有被调用
    auto pipeline = data
        | std::views::filter([&filter_calls](int x) {
            filter_calls++;
            std::cout << "  filter(" << x << ")" << std::endl;
            return x % 2 == 0;
        })
        | std::views::transform([&transform_calls](int x) {
            transform_calls++;
            std::cout << "  transform(" << x << ")" << std::endl;
            return x * x;
        })
        | std::views::take(3);

    std::cout << "创建视图后: filter=" << filter_calls
              << " transform=" << transform_calls << std::endl;
    // 输出: filter=0 transform=0(什么都没做)

    std::cout << "\n开始迭代:" << std::endl;
    for (int v : pipeline) {
        std::cout << "  得到: " << v << std::endl;
    }

    std::cout << "\n迭代后: filter=" << filter_calls
              << " transform=" << transform_calls << std::endl;
    // filter 被调用 6 次(1到6),找到 3 个偶数就停了
    // transform 被调用 3 次(只变换通过 filter 的元素)
}

// ============================
// 示例2:拉模型的执行顺序
// ============================

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

    auto pipeline = data
        | std::views::filter([](int x) {
            std::cout << "F" << x << " ";
            return x % 2 == 0;
        })
        | std::views::transform([](int x) {
            std::cout << "T" << x << " ";
            return x * 10;
        });

    std::cout << "执行顺序: ";
    for (int v : pipeline) {
        std::cout << "=" << v << " | ";
    }
    std::cout << std::endl;
    // 输出类似: F1 F2 T2 =20 | F3 F4 T4 =40 | F5
    // 注意:不是先全部 filter 再全部 transform
    // 而是每个元素依次通过整个管道
}

// ============================
// 示例3:短路——只计算需要的部分
// ============================

void short_circuit_demo() {
    int compute_count = 0;

    // 模拟一个昂贵的计算
    auto expensive = [&compute_count](int x) {
        compute_count++;
        // 假设这是一个耗时操作
        int result = 1;
        for (int i = 0; i < 1000; i++) result += x;
        return result;
    };

    std::vector<int> data(1000000);  // 一百万个元素
    std::iota(data.begin(), data.end(), 1);

    // 即时求值:处理全部 100 万个元素
    // std::vector<int> results;
    // std::transform(data.begin(), data.end(),
    //                std::back_inserter(results), expensive);
    // auto first_3 = std::vector(results.begin(), results.begin() + 3);

    // 惰性求值:只计算前 3 个
    auto first_3 = data
        | std::views::transform(expensive)
        | std::views::take(3);

    for (int v : first_3) {
        // 只迭代 3 次
    }

    std::cout << "实际计算次数: " << compute_count << std::endl;
    // 输出: 3(而不是 1000000)
}

// ============================
// 示例4:无限序列——没有惰性求值就不可能
// ============================

void infinite_demo() {
    // 所有自然数(无限序列)
    auto naturals = std::views::iota(1);

    // 筛选出 3 的倍数(仍然是无限的)
    auto multiples_of_3 = naturals
        | std::views::filter([](int x) { return x % 3 == 0; });

    // 变换为平方(仍然是无限的)
    auto squares = multiples_of_3
        | std::views::transform([](int x) { return x * x; });

    // 取前 5 个——这里才真正计算
    auto first_5 = squares | std::views::take(5);

    std::cout << "无限序列的前5个结果: ";
    for (int v : first_5) std::cout << v << " ";
    std::cout << std::endl;
    // 9 36 81 144 225(3^2, 6^2, 9^2, 12^2, 15^2)
}

// ============================
// 示例5:惰性求值不缓存——多次遍历
// ============================

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

    int call_count = 0;
    auto view = data | std::views::transform([&call_count](int x) {
        call_count++;
        return x * x;
    });

    // 第一次遍历
    std::cout << "第一次: ";
    for (int v : view) std::cout << v << " ";
    std::cout << "(调用 " << call_count << " 次)" << std::endl;

    // 第二次遍历——transform 再次被调用
    std::cout << "第二次: ";
    for (int v : view) std::cout << v << " ";
    std::cout << "(调用 " << call_count << " 次)" << std::endl;
    // 总共调用了 6 次(每次遍历 3 次)
}

// ============================
// 示例6:惰性求值反映底层数据变化
// ============================

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

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

    std::cout << "原始: ";
    for (int v : doubled) std::cout << v << " ";
    std::cout << std::endl;  // 2 4 6 8 10

    // 修改底层数据
    data[0] = 100;
    data.push_back(6);

    // 视图反映变化(因为是惰性的,每次迭代重新计算)
    std::cout << "修改后: ";
    for (int v : doubled) std::cout << v << " ";
    std::cout << std::endl;  // 200 4 6 8 10 12
}

// ============================
// 示例7:何时应该物化(转为容器)
// ============================

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

    // 场景1:只遍历一次——用视图就好
    auto evens = data | std::views::filter([](int x) { return x % 2 == 0; });
    for (int v : evens) std::cout << v << " ";
    std::cout << std::endl;

    // 场景2:需要多次访问或随机访问——物化为容器
    auto sorted_evens = data
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::ranges::to<std::vector>();
    std::ranges::sort(sorted_evens);

    std::cout << "排序后的偶数: ";
    for (int v : sorted_evens) std::cout << v << " ";
    std::cout << std::endl;

    // 场景3:底层数据可能被销毁——必须物化
    // auto make_view() {
    //     std::vector<int> local = {1, 2, 3};
    //     return local | std::views::transform(...);  // 危险!local 会被销毁
    // }
}

int main() {
    std::cout << "=== 惰性证明 ===" << std::endl;
    lazy_proof_demo();

    std::cout << "\n=== 拉模型 ===" << std::endl;
    pull_model_demo();

    std::cout << "\n=== 短路 ===" << std::endl;
    short_circuit_demo();

    std::cout << "\n=== 无限序列 ===" << std::endl;
    infinite_demo();

    std::cout << "\n=== 不缓存 ===" << std::endl;
    no_cache_demo();

    std::cout << "\n=== 反映变化 ===" << std::endl;
    reflect_changes_demo();

    std::cout << "\n=== 物化时机 ===" << std::endl;
    materialize_demo();

    return 0;
}

何时用视图(惰性),何时用容器(即时) ​

场景推荐方式原因
只遍历一次视图零内存分配
需要多次遍历容器(物化)避免重复计算
只需要前 N 个结果视图 + take短路,不计算多余的
需要排序/随机访问容器filter_view 不支持 random_access
底层数据可能被销毁容器视图不拥有数据
处理无限序列视图容器无法存储无限数据
管道组合视图零开销组合

适用场景 ​

  • 数据处理管道中避免中间容器分配
  • 处理大数据集时只需要部分结果
  • 无限序列的生成和截取
  • 需要根据条件提前终止计算的场景
  • 数据流式处理(逐元素处理)

常见问题 ​

惰性求值会影响性能吗?

通常不会。现代编译器会将视图管道内联优化为等价的单循环代码。在某些场景下,惰性求值反而更快——因为避免了中间容器的内存分配,而且 take 可以提前终止。

视图可以缓存计算结果吗?

标准视图不缓存元素值(filter_view 缓存 begin() 位置除外)。如果需要缓存,应该用 ranges::to 物化为容器。

多层视图嵌套会有额外开销吗?

理论上每层视图增加了一层间接调用,但编译器通常能完全内联,生成的代码和手写循环一样。实际测量中,视图管道的性能和手写循环在同一量级。

注意事项 ​

  • 视图创建时不做任何计算
  • 每次迭代都重新计算——不缓存结果
  • 视图反映底层数据的变化
  • 视图不拥有数据——注意底层范围的生命周期
  • 多次遍历的代价是多次计算
  • 需要排序或随机访问时应物化为容器

总结 ​

惰性求值是 C++20 Ranges 视图的根本特性。视图在创建时不做任何计算,只有在迭代时才逐个元素通过管道。这带来了三个关键好处:零中间容器分配(不需要为每一步创建临时 vector)、短路能力(take 可以让管道提前停止)、以及支持无限序列。惰性求值的代价是不缓存结果——多次遍历会多次计算,视图也会反映底层数据的变化。当需要多次访问、随机访问或排序时,应该用 ranges::to 将视图物化为容器。