std::coroutine_traits
| Definiert in Header <coroutine> |
||
| template< class R, class... Args > struct coroutine_traits; |
(seit C++20) | |
Bestimmt den Promise-Typ aus dem Rückgabetyp und den Parametertypen einer Coroutine. Die Standardbibliotheksimplementierung stellt einen öffentlich zugänglichen Member-Typ promise_type bereit, wie R::promise_type, wenn der qualifizierte Bezeichner gültig ist und einen Typ bezeichnet. Andernfalls hat sie kein solches Mitglied.
Programmdefinierte Spezialisierungen von coroutine_traits müssen einen öffentlich zugänglichen verschachtelten Typ promise_type definieren, andernfalls ist das Programm fehlerhaft.
Inhalt |
[bearbeiten] Template-Parameter
| R | - | Rückgabetyp der Coroutine |
| Args | - | Parametertypen der Coroutine, einschließlich des impliziten Objektparameters, wenn die Coroutine eine nicht-statische Member-Funktion ist |
[bearbeiten] Verschachtelte Typen
| Name | Definition |
promise_type
|
R::promise_type, falls gültig, oder bereitgestellt durch programmdefinierte Spezialisierungen |
[bearbeiten] Mögliche Implementierung
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...> {}; |
[bearbeiten] Anmerkungen
Wenn die Coroutine eine nicht-statische Member-Funktion ist, dann ist der erste Typ in Args... der Typ des impliziten Objektparameters, und der Rest sind die Parametertypen der Funktion (falls vorhanden).
Wenn std::coroutine_traits<R, Args...>::promise_type nicht existiert oder kein Klassentyp ist, ist die entsprechende Coroutine-Definition fehlerhaft.
Benutzer können explizite oder partielle Spezialisierungen von coroutine_traits definieren, die von programmddefinierten Typen abhängen, um Modifikationen an den Rückgabetypen zu vermeiden.
[bearbeiten] Beispiel
#include <chrono> #include <coroutine> #include <exception> #include <future> #include <iostream> #include <thread> #include <type_traits> // A program-defined type on which the coroutine_traits specializations below depend struct as_coroutine {}; // Enable the use of std::future<T> as a coroutine type // by using a std::promise<T> as the promise type. 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()); } }; }; // Same for 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()); } }; }; // Allow co_await'ing std::future<T> and std::future<void> // by naively spawning a new thread for each 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) }; } // Utilize the infrastructure we have established. 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 << "error: " << e.what() << '\n'; } }
Ausgabe
42 error: bleah
