CKTIS / C++
std::suspend_always — bezpodmienečné pozastavenie korutiny
std::suspend_always z <coroutine> je jednoduchý awaitable, ktorý pozastaví korutinu bez vytvorenia hodnoty. Neplánuje jej obnovenie: spravujúci kód musí uchovať handle a pozastavenú korutinu obnoviť alebo zničiť.
Verzia: C++23; repository compiler flag, production runtime not attested
Syntax
#include <coroutine>
co_await std::suspend_always{};std::suspend_always z <coroutine> implementuje protokol awaiter. await_ready() vracia false, await_suspend(std::coroutine_handle<>) nič nerobí a vracia void a await_resume() tiež nič nerobí a vracia void. Všetky tri metódy sú constexpr, const a noexcept. Naopak, std::suspend_never vracia z await_ready() hodnotu true.
Keď je tento objekt skutočným awaiterom, co_await std::suspend_always{}; pozastaví korutinu a odovzdá riadenie jej volajúcemu alebo tomu, kto ju obnovuje. Po obnovení vykonávanie pokračuje bez získania hodnoty. Typ neblokuje vlákno, nespúšťa časovač ani neplánuje obnovenie. await_transform objektu promise alebo preťažený operator co_await môžu zmeniť vybraný awaiter.
V príklade initial_suspend() odloží vykonávanie tela až do prvého resume(). Prvé obnovenie vypíše A a dosiahne výslovné pozastavenie; druhé vypíše B a dosiahne final_suspend(). Destruktor vlastníka zničí uchovávaný frame. Kopírovanie vlastníka je zakázané, aby sa predišlo dvojitému zničeniu.
Neobnovujte korutinu v jej konečnom bode pozastavenia a nepoužívajte handle po zničení jej framu. resume() v príklade pred obnovením kontroluje done(). Tento záznam je určený na kompiláciu s -std=c++23; dodaný dokument je priebežne vyvíjaný návrh, nie definitívne vydanie C++23. Podporu kompilátora a produkčného runtime treba overiť lokálne.
Príklady
#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";
}
Výsledok
created A paused B finished
Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.