std::noop_coroutine

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros(C++20) Program utilities Variadic functions initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine support(C++20) Contract support(C++26) Three-way comparison three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

General utilities Function objects Bit manipulation(C++20) bitset hash (C++11) Relational operators(deprecated in C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Coroutine support

Coroutine traits

coroutine_traits (C++20)

Coroutine handle

coroutine_handle (C++20)

No-op coroutines

noop_coroutine_promise (C++20)

noop_coroutine (C++20)

Trivial awaitables

suspend_never (C++20)

suspend_always (C++20)

Range generators

generator (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 to noop_coroutine returns a previously obtained coroutine handle, or a coroutine handle referring to a new coroutine state of no-op coroutine.

Parameters

(none)

Return value

A std::noop_coroutine_handle referring to a no-op coroutine.

Notes

Return values from different calls to noop_coroutine may and may not compare equal.

noop_coroutine may only return a noop_coroutine_handle referring to a coroutine state object without starting a coroutine.

Example

Run this code

#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_return 4;}   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

See also

noop_coroutine_promise (C++20)	used for coroutines with no observable effects (class)
noop_coroutine_handle (C++20)	std::coroutine_handle<std::noop_coroutine_promise>, intended to refer to a no-op coroutine (typedef)