std::coroutine_traits
来自cppreference.com
<tbody>
</tbody>
| 在标头 <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