CKTIS / C++
std::suspend_always — brezpogojna prekinitev korutine
std::suspend_always iz <coroutine> je preprost awaitable, ki prekine korutino, ne da bi ustvaril vrednost. Ne načrtuje njenega nadaljevanja: koda, ki jo upravlja, mora ohraniti handle ter prekinjeno korutino nadaljevati ali uničiti.
Različica: C++23; repository compiler flag, production runtime not attested
Sintaksa
#include <coroutine>
co_await std::suspend_always{};std::suspend_always iz <coroutine> implementira protokol awaiter. await_ready() vrne false, await_suspend(std::coroutine_handle<>) ne naredi ničesar in vrne void, await_resume() pa prav tako ne naredi ničesar in vrne void. Vse tri metode so constexpr, const in noexcept. Nasprotno std::suspend_never iz await_ready() vrne true.
Ko je ta objekt dejanski awaiter, co_await std::suspend_always{}; prekine korutino in vrne nadzor njenemu klicatelju ali tistemu, ki jo nadaljuje. Po nadaljevanju se izvajanje nadaljuje, ne da bi pridobilo vrednost. Ta tip ne blokira niti, ne zažene časovnika in ne načrtuje nadaljevanja. await_transform objekta promise ali preobremenjeni operator co_await lahko spremeni izbrani awaiter.
V primeru initial_suspend() odloži izvajanje telesa do prvega resume(). Prvo nadaljevanje izpiše A in doseže izrecno prekinitev; drugo izpiše B in doseže final_suspend(). Destruktor lastnika uniči ohranjeni frame. Kopiranje lastnika je prepovedano, da se prepreči dvojno uničenje.
Korutine ne nadaljujte na njeni končni točki prekinitve in ne uporabljajte handle po uničenju njenega frame. resume() v primeru pred nadaljevanjem preveri done(). Ta vnos je namenjen prevajanju z -std=c++23; priloženi dokument je osnutek, ki se še razvija, in ne dokončna objava C++23. Podporo prevajalnika in produkcijskega izvajalnega okolja je treba preveriti lokalno.
Primeri
#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";
}
Rezultat
created A paused B finished
Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.