C++20/26 新特性实战：用 Concepts、Ranges 与 Sender/Receiver 重塑异步编程

Hope.339

467人浏览 · 2026-03-25 10:08:13

Hope.339 · 2026-03-25 10:08:13 发布

前言

欢迎来到“现代 C++ 高性能开发”系列的第五期！
在前四期中，我们构建了坚实的地基：

智能指针：让内存管理自动化。
移动语义：让数据传输零拷贝。
STL 容器与算法：让数据处理泛型化。
并发编程：让多核 CPU 全力运转。

但你是否觉得：

模板报错信息依然像“天书”？
异步回调嵌套让人头晕目眩（Callback Hell）？
手写线程池和任务调度复杂且易错？

C++20 和即将到来的 C++26 标准，正是为了解决这些问题而生！
本期，我们将深入 Concepts、Ranges、Coroutines 以及 C++26 的杀手锏 std::execution (Sender/Receiver)，看看它们如何与前四期的知识结合，打造出既安全、又快速、还优雅的现代 C++ 代码。

一、Concepts：让模板报错不再可怕

在 C++20 之前，模板元编程的错误信息是出了名的难懂。编译器会抛出几十行无关的实例化堆栈，让你找不到北。

C++20 Concepts 引入了“约束”，让你在编译期就能明确告诉编译器：“这个模板只接受满足特定条件的类型”。

❌ 旧式模板（报错晦涩）

template<typename T>
auto add(T a, T b) {
    return a + b; // 如果 T 是 std::string 没问题，如果是 MyClass 且没重载 +，报错信息长达 50 行
}

✅ 现代写法（清晰约束）

#include <concepts>

// 定义一个概念：类型必须支持加法运算
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

// 使用概念约束模板参数
template<Addable T>
T add(T a, T b) {
    return a + b;
}

// 调用
add(1, 2); // OK
add(std::string("a"), std::string("b")); // OK
// add(MyClass{}, MyClass{}); // 编译报错：清晰提示 "MyClass does not satisfy concept Addable"

优势：

编译期检查：错误在实例化前就被捕获。
可读性：代码即文档，一眼看出函数对类型的要求。
配合移动语义：你可以定义 Movable 概念，确保传入类型支持高效移动。

二、Ranges：算法的函数式革命

C++20 的 Ranges 库让 STL 算法支持链式调用，并且是惰性求值（Lazy Evaluation）。这意味着数据流在处理过程中不会生成中间容器，完美契合我们第二期讲的“移动语义”和“零拷贝”理念。

❌ 传统写法（中间容器，多次遍历）

std::vector<int> nums = {1, 2, 3, 4, 5, 6};
std::vector<int> temp;
for (int n : nums) {
    if (n % 2 == 0) temp.push_back(n);
}
std::vector<int> result;
for (int n : temp) {
    result.push_back(n * 10);
}
// 创建了 temp 中间容器，内存分配开销大

✅ Ranges 写法（零拷贝，流水线处理）

#include <ranges>
#include <vector>
#include <iostream>

std::vector<int> nums = {1, 2, 3, 4, 5, 6};

// 链式调用：过滤 -> 转换
auto result = nums 
    | std::views::filter([](int n){ return n % 2 == 0; })
    | std::views::transform([](int n){ return n * 10; });

// 只有当遍历 result 时，计算才会发生
for (int v : result) {
    std::cout << v << " "; // 输出：20 40 60
}
// 没有创建任何临时 vector，内存占用极低，逻辑清晰如 Python

与前四期的结合：

移动语义：transform 中可以返回移动后的对象，避免拷贝。
智能指针：可以直接处理 std::vector<std::unique_ptr<T>>，在管道中转移所有权。

三、Coroutines (C++20)：告别回调地狱

第四期我们讲了多线程，但处理大量异步 IO（如网络请求）时，传统的回调或 std::future 会让代码支离破碎。

C++20 协程允许函数暂停 (co_await) 和恢复，用同步的写法实现异步逻辑。

#include <coroutine>
#include <iostream>
#include <thread>
#include <chrono>

// 一个简单的 Task 协程包装器（简化版）
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

// 模拟异步操作
Task fetch_data(int id) {
    std::cout << "Start fetching " << id << "\n";
    co_await std::suspend_always{}; // 模拟挂起，让出线程
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟 IO 等待
    std::cout << "Data " << id << " ready\n";
}

int main() {
    auto t1 = fetch_data(1);
    auto t2 = fetch_data(2);
    // 在实际框架中（如 cppcoro 或 C++26 exec），这里会有一个事件循环调度它们
    // 单线程即可并发处理多个 IO 任务
}

核心收益：

代码线性：逻辑一目了然，没有嵌套回调。
资源高效：协程栈空间小，单线程可承载数万并发。
配合智能指针：协程帧中持有的 unique_ptr 在挂起和恢复间依然安全。

四、C++26 杀手锏：std::execution (Sender/Receiver)

这是 C++26 最激动人心的特性（基于 P2300 提案）。它旨在统一所有异步模型（线程、协程、GPU、网络 IO）。

传统的 std::async 或协程往往局限于特定上下文。而 Sender/Receiver 模型将异步操作描述为可组合的对象（Sender），并指定在哪里执行（Scheduler）。

核心概念

Sender：描述一个异步操作（如“读取文件”），但不立即执行。
Receiver：定义操作完成后如何处理结果（成功、失败、取消）。
Scheduler：决定操作在哪运行（线程池、GPU、当前线程）。

实战示例（概念代码，需 C++26 支持或 exec 库）

#include <execution>
#include <iostream>

// 假设有一个线程池调度器
auto pool = std::execution::thread_pool_scheduler();

// 构建一个异步任务链
auto sender = 
    std::execution::just(10) // 产生初始值
    | std::execution::then([](int x){ return x * 2; }) // 转换
    | std::execution::on(pool) // 指定在线程池运行
    | std::execution::then([](int x){ 
          std::cout << "Result: " << x << " on thread " << std::this_thread::get_id() << "\n"; 
      });

// 启动执行
auto [res] = std::execution::sync_wait(sender).value(); 
// sync_wait 阻塞直到完成，实际生产中通常 fire_and_forget 或连接到 UI 事件循环

为什么它是未来？

结构化并发：自动管理生命周期，避免“发射后不管”导致的资源泄漏。
零开销抽象：编译器可以内联整个链条，性能媲美手写状态机。
异构计算：同一套代码可以轻松调度到 CPU、GPU 或 FPGA。
与前四期完美融合：

- 移动语义：Sender 之间传递数据默认使用移动。
- 智能指针：Receiver 中可安全持有共享资源。
- Concepts：Sender/Receiver 接口完全基于 Concepts 定义，类型安全。

五、避坑指南与最佳实践

不要滥用协程：
协程有栈分配开销。对于纯 CPU 密集型计算，传统线程或 std::async 可能更快。协程最适合 IO 密集型场景。
Concepts 不是银弹：
虽然 Concepts 让报错更清晰，但过度复杂的约束会让编译变慢。保持概念简单、正交。
Ranges 的陷阱：
views 是惰性的，不拥有数据。务必确保底层数据（如 vector）在 views 使用期间存活，否则会出现悬空引用。
C++26 的过渡：
目前 std::execution 还在标准化最后阶段。生产环境可使用 libunifex 或 boost::asio (支持 P2300 风格) 进行提前适配。