CKTIS / C++
std::suspend_never — attendre sans suspendre une coroutine
std::suspend_never, fourni par <coroutine>, est un awaiter simple qui ne suspend pas une coroutine et ne produit aucune valeur. Il permet de définir le démarrage ou l’achèvement immédiat d’une coroutine ; à l’achèvement, la durée de vie de son état doit être surveillée avec soin.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <coroutine>
co_await std::suspend_never{};std::suspend_never est un type de <coroutine> dont les objets peuvent servir directement d’awaiter pour co_await. Il ne suspend pas la coroutine et ne produit aucune valeur : le type de résultat est void. À l’inverse, std::suspend_always, utilisé directement comme awaiter, suspend toujours la coroutine.
await_ready() renvoie true ; le protocole d’attente omet donc await_suspend(std::coroutine_handle<>) et appelle await_resume(). Les deux dernières fonctions ne font rien et renvoient void ; les trois sont constexpr, const et noexcept. Cela empêche la suspension à ce point précis, et non pendant toute la coroutine. Un await_transform personnalisé dans le promise peut modifier l’interprétation de l’opérande de co_await.
Les expressions co_await implicites associées à initial_suspend() et à final_suspend() ignorent await_transform, mais peuvent tout de même sélectionner un operator co_await surchargé qui fournit un awaiter capable de suspendre la coroutine. Le type de retour ne garantit donc pas à lui seul l’absence de suspension. Si l’objet std::suspend_never renvoyé par initial_suspend() sert lui-même d’awaiter, l’exécution passe directement au corps de la coroutine. Si l’objet renvoyé par final_suspend() sert lui-même d’awaiter, il n’y a pas de suspension finale et l’état de la coroutine est détruit à son achèvement. Tout handle conservé vers cet état devient invalide : il ne faut ensuite appeler par son intermédiaire ni resume(), ni done(), ni destroy().
Dans l’exemple, immediate_task ne stocke aucun handle. run() effectue les deux affichages avant de revenir à main(), et son état est nettoyé automatiquement. Cette entrée vise C++23 ; le site cité héberge un projet de norme en évolution, et non une publication C++23 figée. L’exécution dans un environnement de production n’a pas été attestée.
Exemples
#include <coroutine>
#include <exception>
#include <iostream>
struct immediate_task {
struct promise_type {
immediate_task get_return_object() noexcept { return {}; }
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() noexcept { std::terminate(); }
};
};
immediate_task run() {
std::cout << "before\n";
co_await std::suspend_never{};
std::cout << "after\n";
co_return;
}
int main() {
run();
std::cout << "returned\n";
}
Résultat
before after returned
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.