c++20中的协程（coroutines）怎么用_c++20协程使用方法

c++20协程通过co_await、co_yield、co_return实现暂停与恢复，用于异步编程和生成器；需定义含promise_type的返回类型，控制初始、最终挂起及返回行为；示例展示整数生成器和异步等待的实现机制。

C++20 引入了协程（Coroutines），它是一种可以暂停和恢复执行的函数，适用于异步编程、生成器、任务调度等场景。协程不是线程，它运行在当前线程中，通过 co_await、co_yield 或 co_return 来标记一个函数为协程。

1. 判断一个函数是协程

只要函数体内包含以下任意一个关键字，编译器就会将其视为协程：

• co_await：等待一个可等待对象（awaiter）
• co_yield：产生一个值并暂停
• co_return：结束协程并返回结果

例如：

#include <coroutine>
#include <iostream>
<p>struct [[nodiscard]] task {
struct promise_type {
task get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
};</p><p>task my_coroutine() {
std::cout << "协程开始\n";
co_await std::suspend_always{};
std::cout << "协程恢复\n";
co_return;
}</p>

2. 协程的核心组件

要使用协程，必须定义一个返回类型，该类型包含嵌套的 promise_type。这个结构决定了协程的行为。

立即学习“C++免费学习笔记（深入）”；

常见成员函数包括：

• get_return_object()：创建并返回协程句柄关联的对象
• initial_suspend()：协程启动时是否暂停（std::suspend_always 暂停，std::suspend_never 不暂停）
• final_suspend()：协程结束时是否暂停
• return_void() 或 return_value(T)：处理 co_return
• unhandled_exception()：异常处理

3. 使用 co_yield 实现生成器

常见用途之一是实现惰性生成器。下面是一个简单的整数生成器示例：

Grammarly

Grammarly是一款在线语法纠正和校对工具，伟大的AI辅助写作工具

下载

#include <coroutine>
#include <iostream>
#include <exception>
<p>template<typename T>
struct generator {
struct promise<em>type {
T value</em>;
generator get_return_object() { return generator{this}; }
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
std::suspend_always yield<em>value(T value) {
value</em> = value;
return {};
}
void return_void() {}
void unhandled_exception() { std::terminate(); }
};</p><pre class='brush:php;toolbar:false;'>using handle_type = std::coroutine_handle<promise_type>;

explicit generator(promise_type* p)
    : coro_(handle_type::from_promise(*p)) {}

~generator() { if (coro_) coro_.destroy(); }

bool move_next() {
    if (!coro_ || coro_.done()) return false;
    coro_.resume();
    return !coro_.done();
}

T current_value() const { return coro_.promise().value_; }

private: handletype coro; };

generator range(int from, int to) { for (int i = from; i

int main() { for (auto g = range(1, 6); g.move_next();) { std::cout

输出：

4. 使用 co_await 实现异步等待

你可以定义自己的可等待类型，实现异步操作的挂起与恢复。

struct suspend_immediate {
    bool await_ready() { return false; } // 立即挂起
    void await_suspend(std::coroutine_handle<> h) {
        std::cout << "协程被挂起，即将恢复...\n";
        h.resume(); // 立即恢复（可用于调度）
    }
    void await_resume() {}
};
<p>generator<void> async_example() {
std::cout << "第一步\n";
co_await suspend_immediate{};
std::cout << "第三步\n";
}</p>

这段代码会依次输出：

说明协程在 co_await 处暂停，并由 await_suspend 控制何时恢复。

基本上就这些。C++20 协程底层灵活但需要手动封装，建议结合现有库如 cppcoro 或 Boost.Asio 来简化使用。不复杂但容易忽略细节。