База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

std::suspend_always — безусловно спиране на корутина

std::suspend_always от <coroutine> е прост awaitable, който спира корутина, без да създава стойност. Той не планира подновяването ѝ: управляващият код трябва да запази handle и да поднови или унищожи спряната корутина.

Версия: C++23; repository compiler flag, production runtime not attested

Синтаксис

#include <coroutine>
co_await std::suspend_always{};

std::suspend_always от <coroutine> реализира протокола awaiter. await_ready() връща false, await_suspend(std::coroutine_handle<>) не прави нищо и връща void, а await_resume() също не прави нищо и връща void. И трите метода са constexpr, const и noexcept. За разлика от него, std::suspend_never връща true от await_ready().

Когато този обект е действителният awaiter, co_await std::suspend_always{}; спира корутината и връща управлението на нейния извикващ код или на този, който я подновява. След подновяването изпълнението продължава, без да се получава стойност. Типът не блокира нишката, не стартира таймер и не планира подновяване. await_transform на обекта promise или претоварен operator co_await може да промени избрания awaiter.

В примера initial_suspend() отлага изпълнението на тялото до първото извикване на resume(). Първото подновяване отпечатва A и достига изричното спиране; второто отпечатва B и достига final_suspend(). Деструкторът на собственика унищожава запазения frame. Копирането на собственика е забранено, за да се предотврати двойно унищожаване.

Не подновявайте корутина в крайната ѝ точка на спиране и не използвайте handle след унищожаването на нейния frame. resume() в примера проверява done() преди подновяване. Този запис е предназначен за компилиране с -std=c++23; предоставеният документ е развиващ се проект, а не окончателна публикация на C++23. Поддръжката от компилатора и продукционната среда за изпълнение трябва да се провери локално.

Примери

#include <coroutine>
#include <exception>
#include <iostream>

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    explicit Task(std::coroutine_handle<promise_type> h) : handle(h) {}
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    ~Task() { handle.destroy(); }

    void resume() {
        if (!handle.done()) handle.resume();
    }
};

Task work() {
    std::cout << "A\n";
    co_await std::suspend_always{};
    std::cout << "B\n";
}

int main() {
    auto task = work();
    std::cout << "created\n";
    task.resume();
    std::cout << "paused\n";
    task.resume();
    std::cout << "finished\n";
}

Резултат

created
A
paused
B
finished

Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.

Източници