# std::noop_coroutine

< cpp‎ | coroutine

定义于头文件 `<coroutine>` |  |
std::noop_coroutine_handle noop_coroutine() noexcept; |  | (C++20 起)

返回指代无操作协程的协程柄。

若已有无操作协程的协程状态，则不指定 `noop_coroutine` 的后续调用是返回先前获得的协程柄，还是指代新的无操作协程的协程状态的协程柄。

### 参数

（无）

### 返回值

指代无操作协程的 std::noop_coroutine_handle 。

### 注解

不同的 `noop_coroutine` 调用的返回值可能也可能不比较相等。

`noop_coroutine` 可以仅返回指代协程状态对象的 `noop_coroutine_handle` 而无需开始协程。

### 示例

    #include <coroutine>
    #include <utility>
    #include <iostream>

    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() { return false; }
                void await_resume() {}
                std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) {
                    // 在当前协程（以 'h' 指代）执行即将结束时调用 final_awaiter::await_suspend 。
                    // 若当前协程被另一协程经由 co_await get_task() 恢复，则存储到该协程的柄
                    // 为 h.promise().previous 。该情况下，返回柄以恢复先前的协程。
                    // 否则返回 noop_coroutine() ，其恢复不做任何事。

                    auto previous = h.promise().previous;
                    if (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';
    }

输出：

    in test()
    in get_random()
    in get_random()
    8

### 参阅

noop_coroutine_promise (C++20) | 用于无可观察作用的协程 (类)
noop_coroutine_handle (C++20) | std::coroutine_handle<std::noop_coroutine_promise> ，有意用于指代无操作协程 (typedef)