std::coroutine_traits
来自cppreference.com
| 在标头 <coroutine> 定义
|
||
| template< class R, class... Args > struct coroutine_traits; |
(C++20 起) | |
从协程的返回类型与形参类型确定承诺类型。如果限定标识 R::promise_type 合法并代表一个类型，那么标准库实现提供与该类型相同的公开可访问成员类型 promise_type。否则无此成员。
coroutine_traits 的由程序定义的特化必须定义公开可访问的嵌套类型 promise_type，否则程序非良构。
模板形参
| R | - | 协程的返回类型 |
| Args | - | 协程的形参类型，若协程为非静态成员函数则包括隐式对象形参 |
嵌套类型
| 名字 | 定义 |
promise_type
|
R::promise_type（如果合法），或由程序定义的特化提供
|
可能的实现
namespace detail { template<class, class...> struct coroutine_traits_base {}; template<class R, class... Args> requires requires { typename R::promise_type; } struct coroutine_traits_base <R, Args...> { using promise_type = R::promise_type; }; } template<class R, class... Args> struct coroutine_traits : detail::coroutine_traits_base<R, Args...> {}; |
注解
如果协程是非静态成员函数，那么 Args... 中的首个类型为隐式对象形参的类型，而剩下的是函数的形参类型（如果存在）。
如果 std::coroutind_traits<R, Args...>::promise_type 不存在或不是类类型，那么对应的协程定义非良构。
用户可定义取决于程序定义类型的 coroutine_traits 显式或部分特化，以避免修改返回类型。
示例
运行此代码
#include <chrono> #include <coroutine> #include <exception> #include <future> #include <iostream> #include <thread> #include <type_traits> // 程序定义的类型，下面提供 coroutine_traits 针对它的特化 struct as_coroutine {}; // 通过使用 std::promise<T> 为承诺类型， // 允许将 std::future<T> 用作协程类型。 template<typename T, typename... Args> requires(!std::is_void_v<T> && !std::is_reference_v<T>) struct std::coroutine_traits<std::future<T>, as_coroutine, Args...> { struct promise_type : std::promise<T> { std::future<T> get_return_object() noexcept { return this->get_future(); } std::suspend_never initial_suspend() const noexcept { return {}; } std::suspend_never final_suspend() const noexcept { return {}; } void return_value(const T& value) noexcept(std::is_nothrow_copy_constructible_v<T>) { this->set_value(value); } void return_value(T&& value) noexcept(std::is_nothrow_move_constructible_v<T>) { this->set_value(std::move(value)); } void unhandled_exception() noexcept { this->set_exception(std::current_exception()); } }; }; // 与 std::future<void> 相同 template<typename... Args> struct std::coroutine_traits<std::future<void>, as_coroutine, Args...> { struct promise_type : std::promise<void> { std::future<void> get_return_object() noexcept { return this->get_future(); } std::suspend_never initial_suspend() const noexcept { return {}; } std::suspend_never final_suspend() const noexcept { return {}; } void return_void() noexcept { this->set_value(); } void unhandled_exception() noexcept { this->set_exception(std::current_exception()); } }; }; // 通过单纯地为每个 co_await 孵化新线程， // 允许对 std::future<T> 和 std::future<void> 的 co_await。 template<typename T> auto operator co_await(std::future<T> future) noexcept requires(!std::is_reference_v<T>) { struct awaiter : std::future<T> { bool await_ready() const noexcept { using namespace std::chrono_literals; return this->wait_for(0s) != std::future_status::timeout; } void await_suspend(std::coroutine_handle<> cont) const { std::thread([this, cont] { this->wait(); cont(); }).detach(); } T await_resume() { return this->get(); } }; return awaiter { std::move(future) }; } // 利用已经建立的架构。 std::future<int> compute(as_coroutine) { int a = co_await std::async([] { return 6; }); int b = co_await std::async([] { return 7; }); co_return a * b; } std::future<void> fail(as_coroutine) { throw std::runtime_error("bleah"); co_return; } int main() { std::cout << compute({}).get() << '\n'; try { fail({}).get(); } catch (const std::runtime_error& e) { std::cout << "错误：" << e.what() << '\n'; } }
输出：
42 错误：bleah