CKTIS / C++
std::suspend_always — suspension inconditionnelle d’une coroutine
std::suspend_always de <coroutine> est un awaitable simple qui suspend une coroutine sans produire de valeur. Il ne programme pas sa reprise : le code de gestion doit conserver un handle et reprendre ou détruire la coroutine suspendue.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <coroutine>
co_await std::suspend_always{};std::suspend_always de <coroutine> implémente le protocole awaiter. await_ready() renvoie false, await_suspend(std::coroutine_handle<>) ne fait rien et renvoie void, et await_resume() ne fait rien et renvoie void. Ces trois méthodes sont constexpr, const et noexcept. À l’inverse, std::suspend_never renvoie true depuis await_ready().
Lorsque cet objet est effectivement l’awaiter, co_await std::suspend_always{}; suspend la coroutine et rend le contrôle à son appelant ou à celui qui la reprend. Après la reprise, l’exécution continue sans obtenir de valeur. Ce type ne bloque pas le thread, ne démarre pas de minuteur et ne programme pas la reprise. await_transform de la promesse ou un operator co_await surchargé peut modifier l’awaiter sélectionné.
Dans l’exemple, initial_suspend() retarde l’exécution du corps jusqu’au premier resume(). La première reprise affiche A et atteint la suspension explicite ; la seconde affiche B et atteint final_suspend(). Le destructeur du propriétaire détruit le frame conservé. La copie du propriétaire est interdite afin d’éviter une double destruction.
Ne reprenez pas une coroutine à son point de suspension final et n’utilisez pas un handle après la destruction de son frame. Le resume() de l’exemple vérifie done() avant la reprise. Cette entrée vise une compilation avec -std=c++23 ; le document fourni est un brouillon évolutif, et non une publication C++23 définitive. La prise en charge par le compilateur et l’environnement d’exécution de production doit être vérifiée localement.
Exemples
#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";
}
Résultat
created A paused B finished
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.