Namespaces
Variants

std:: noop_coroutine

From cppreference.net
C++
Utilities library
Coroutine support
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)
헤더 파일에 정의됨 <coroutine>
std:: noop_coroutine_handle noop_coroutine ( ) noexcept ;
(C++20 이후)

아무 작업도 수행하지 않는 코루틴을 참조하는 코루틴 핸들을 반환합니다.

이미 no-op 코루틴의 코루틴 상태가 존재하는 경우, 이후 noop_coroutine 호출이 이전에 얻은 코루틴 핸들을 반환하는지, 아니면 새로운 no-op 코루틴 상태를 참조하는 코루틴 핸들을 반환하는지는 명시되지 않습니다.

목차

매개변수

(없음)

반환값

no-op 코루틴을 참조하는 std::noop_coroutine_handle 입니다.

참고 사항

noop_coroutine 에 대한 서로 다른 호출에서 반환된 값들은 같을 수도 있고 같지 않을 수도 있습니다.

noop_coroutine 는 코루틴을 시작하지 않고 코루틴 상태 객체를 참조하는 noop_coroutine_handle 만 반환할 수 있습니다.

예제

이 코드 실행 
#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 { return false; }
            void await_resume() noexcept {}
            std::coroutine_handle<>
                await_suspend(std::coroutine_handle<promise_type> h) noexcept
            {
                // final_awaiter::await_suspend는 코루틴의 실행이 일시 중단될 때 호출됩니다
                // 현재 코루틴('h'로 참조됨)이 곧 종료됩니다.
                // 현재 코루틴이 다른 코루틴에 의해 재개된 경우
                // co_await get_task(), 해당 코루틴에 대한 핸들이 저장됨
                // h.promise().previous와 같은 경우. 이 경우 재개할 핸들을 반환
                // 이전 코루틴.
                // 그렇지 않으면, 재개 시 아무 작업도 수행하지 않는 noop_coroutine()을 반환합니다.
                if (auto previous = h.promise().previous; previous)
                    return previous;
                else
                    return 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() { return false; }
        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';
}

출력: 

test() 함수 내부
get_random() 함수 내부
get_random() 함수 내부
8

참고 항목

(C++20)
관찰 가능한 효과가 없는 코루틴에 사용됨
(클래스)
(C++20)
std:: coroutine_handle < std:: noop_coroutine_promise > , no-op 코루틴을 참조하기 위한 목적
(typedef)