|
|
Coroutine traits | ||||
(C++20) | ||||
Coroutine handle | ||||
(C++20) | ||||
No-op coroutines | ||||
(C++20) | ||||
noop_coroutine (C++20) | ||||
Trivial awaitables | ||||
(C++20) | ||||
(C++20) | ||||
Range generators | ||||
(C++23) |
Defined in header <coroutine> | ||
std::noop_coroutine_handle noop_coroutine()noexcept; | (since C++20) | |
Returns a coroutine handle referring to a no-op coroutine.
If there has been already a coroutine state of no-op coroutine, it is unspecified whether a subsequent call tonoop_coroutine
returns a previously obtained coroutine handle, or a coroutine handle referring to a new coroutine state of no-op coroutine.
Contents |
(none)
Astd::noop_coroutine_handle referring to a no-op coroutine.
Return values from different calls tonoop_coroutine
may and may not compare equal.
noop_coroutine
may only return anoop_coroutine_handle
referring to a coroutine state object without starting a coroutine.
#include <coroutine>#include <iostream>#include <utility> template<class T>struct task{struct promise_type{auto get_return_object(){return task(std::coroutine_handle<promise_type>::from_promise(*this));}std::suspend_always initial_suspend(){return{};}struct final_awaiter{bool await_ready()noexcept{returnfalse;}void await_resume()noexcept{}std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h)noexcept{// final_awaiter::await_suspend is called when the execution of the// current coroutine (referred to by 'h') is about to finish.// If the current coroutine was resumed by another coroutine via// co_await get_task(), a handle to that coroutine has been stored// as h.promise().previous. In that case, return the handle to resume// the previous coroutine.// Otherwise, return noop_coroutine(), whose resumption does nothing. if(auto previous= h.promise().previous; previous)return previous;elsereturn std::noop_coroutine();}}; final_awaiter final_suspend()noexcept{return{};}void unhandled_exception(){throw;}void return_value(T value){ result= std::move(value);} T result;std::coroutine_handle<> previous;}; task(std::coroutine_handle<promise_type> h): coro(h){} task(task&& t)= delete; ~task(){ coro.destroy();} struct awaiter{bool await_ready(){returnfalse;} T await_resume(){return std::move(coro.promise().result);}auto await_suspend(std::coroutine_handle<> h){ coro.promise().previous= h;return coro;}std::coroutine_handle<promise_type> coro;}; awaiter operator co_await(){return awaiter{coro};} T operator()(){ coro.resume();return std::move(coro.promise().result);} private:std::coroutine_handle<promise_type> coro;}; task<int> get_random(){std::cout<<"in get_random()\n"; co_return4;} task<int> test(){ task<int> v= get_random(); task<int> u= get_random();std::cout<<"in test()\n";int x=(co_await v+ co_await u); co_return x;} int main(){ task<int> t= test();int result= t();std::cout<< result<<'\n';}
Output:
in test()in get_random()in get_random()8
(C++20) | used for coroutines with no observable effects (class)[edit] |
(C++20) | std::coroutine_handle<std::noop_coroutine_promise>, intended to refer to a no-op coroutine (typedef)[edit] |