CKTIS / C++
co_await — Warten in einer Coroutine
Der Ausdruck co_await verwendet das Awaiter-Protokoll, um eine Coroutine gegebenenfalls anzuhalten und anschließend ein Ergebnis zu erhalten. Er startet selbst weder einen Thread noch stellt er eine Planung bereit; für die Fortsetzung muss die verwendete Implementierung sorgen.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
co_await cast-expressionco_await expression kennzeichnet einen möglichen Anhaltepunkt einer Coroutine, kein blockierendes Warten eines Threads. Ein solcher Ausdruck im Funktionskörper macht die Funktion zu einer Coroutine. Der Typ ihres Promise-Objekts wird über std::coroutine_traits bestimmt. Dieses Template muss für den Rückgabetyp und die Parametertypen der Coroutine (einschließlich des Objektparameters bei einer nichtstatischen Memberfunktion) ein passendes promise_type bereitstellen. Der Rückgabetyp selbst benötigt kein geschachteltes promise_type. Der Operator selbst erzeugt weder einen Thread noch einen Scheduler.
Wird bei einem expliziten co_await im Typ des Promise-Objekts eine Deklaration von await_transform gefunden, ist das Ergebnis des Aufrufs von await_transform auf dem Promise-Objekt mit dem Operanden als Argument das Awaitable. Andernfalls ist der ursprüngliche Operand das Awaitable. Wählt die Überladungsauflösung für das Awaitable einen operator co_await aus, dient dessen Aufrufergebnis als Awaiter. Nur wenn die Kandidatenmenge für operator co_await leer ist, dient das Awaitable selbst als Awaiter — gegebenenfalls nach der Umwandlung. Ist die Kandidatenmenge nicht leer, enthält aber keine verwendbare Funktion, ist der co_await-Ausdruck nicht wohlgeformt. Der Awaiter stellt await_ready(), await_suspend(h) und await_resume() bereit. Der Ausdruck hat den Typ und die Wertkategorie des Ergebnisses von await_resume().
Das Ergebnis von await_ready() wird kontextuell in bool konvertiert. Ergibt die Konvertierung true, wird die Coroutine nicht angehalten. Das gilt auch für ein Ergebnis mit Klassentyp, dessen explicit operator bool() den Wert true zurückgibt. Ergibt die Konvertierung false, wird die Coroutine angehalten und await_suspend(h) aufgerufen. Hat await_suspend den Rückgabetyp void, löst die Rückkehr aus dem Aufruf für sich genommen keine Fortsetzung durch den co_await-Mechanismus aus. await_suspend kann die Coroutine aber selbst fortsetzen oder sie von einem anderen Thread fortsetzen lassen, auch schon vor der Rückkehr aus dem Aufruf. Ein bool-Ergebnis mit dem Wert false setzt die Coroutine sofort fort; die Rückgabe eines Coroutine-Handles überträgt die Ausführung an die angegebene Coroutine. await_resume() liefert das Ergebnis, wenn die Ausführung weitergeht.
Das Beispiel verwendet std::suspend_always: run() gibt start aus und übergibt die Kontrolle; resume() ermöglicht die Ausgabe von resumed. final_suspend() lässt den Frame angehalten, damit der Destruktor von Task ihn freigeben kann. Eine Coroutine darf niemals an ihrem endgültigen Anhaltepunkt fortgesetzt werden; Objekte, die nach der Fortsetzung verwendet werden, müssen noch leben.
Dieser Eintrag bezieht sich auf C++23; die angegebene Website veröffentlicht einen fortlaufend weiterentwickelten Entwurf, keinen eingefrorenen C++23-Text. Die Kompatibilität mit der Produktionslaufzeit ist nicht bestätigt.
Beispiele
#include <coroutine>
#include <exception>
#include <iostream>
struct Task {
struct promise_type;
using Handle = std::coroutine_handle<promise_type>;
struct promise_type {
Task get_return_object() {
return Task{Handle::from_promise(*this)};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() noexcept { std::terminate(); }
};
Handle handle;
explicit Task(Handle h) noexcept : handle(h) {}
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
~Task() { handle.destroy(); }
};
Task run() {
std::cout << "start\n";
co_await std::suspend_always{};
std::cout << "resumed\n";
}
int main() {
auto task = run();
std::cout << "caller\n";
task.handle.resume();
}
Ergebnis
start caller resumed
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.