Einen einfachen Generator implementieren
Erstellen Sie eine Generator-Coroutine, die Werte verzögert liefert.
Einen einfachen Generator implementieren ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Generatoren als Coroutines
Ein Generator ist eine Coroutine, die Werte einzeln liefert. Jeder Aufruf des Generators erzeugt den nächsten Wert und hält die Ausführung an.
Der Generatortyp
Definieren Sie eine Klasse mit einem verschachtelten Typ promise_type. Der Compiler verwendet ihn, um den Zustand der Coroutine zu verwalten.
template <typename T>
struct Generator {
struct promise_type {
T current_value;
Generator get_return_object() {
return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
std::suspend_always yield_value(T value) {
current_value = value;
return {};
}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> h;
// ... constructors, destructor, next() ...
};Den Generator verwenden
Sobald sie definiert sind, fühlen sich Generatoren wie Python yield an.
Generator<int> counting() {
int n = 0;
while (true) co_yield n++;
}
auto g = counting();
for (int i = 0; i < 5; ++i) {
std::cout << g.next() << " ";
}
// 0 1 2 3 4coroutine_handle
Der Compiler gibt ein std::coroutine_handle zurück. Es repräsentiert die angehaltene Coroutine – Sie können resume() oder destroy() aufrufen oder mit done() prüfen, ob sie beendet ist.
Anhaltepunkte
Jedes co_yield hält die Ausführung an. Wenn der Aufrufer resume() aufruft, wird die Ausführung bis zum nächsten Anhaltepunkt oder bis zum Ende der Coroutine fortgesetzt.
initial_suspend und final_suspend
Zwei Anpassungspunkte:
initial_suspend– geben Siesuspend_alwaysfür einen verzögerten Start undsuspend_neverfür einen sofortigen Start zurückfinal_suspend– steuert die Bereinigung. Für eine ordnungsgemäße Zerstörung wird normalerweisesuspend_alwaysverwendet
C++23 std::generator
C++23 hat std::generator in <generator> hinzugefügt. Für den üblichen Anwendungsfall müssen Sie den Typ nicht mehr selbst entwickeln.
#include <generator>
std::generator<int> counting() {
int n = 0;
while (true) co_yield n++;
}Bereichsbasierte for-Schleife
Wenn der Generatortyp begin/end unterstützt, funktioniert die bereichsbasierte for-Schleife direkt.
for (int x : counting()) {
if (x >= 10) break;
std::cout << x;
}Pull- und Push-Semantik
Generatoren sind Pull-basiert – der Aufrufer steuert die Iteration. Push-basierte Coroutines sind asynchrone Tasks.
Anwendungsfälle
Generatoren eignen sich hervorragend für:
- Verzögerte Sequenzen (Fibonacci-Zahlen, Primzahlen, zeilenweise lesende Dateien)
- Streaming-Daten ohne vorherige Materialisierung
- Die Iteration über baumartige Strukturen
Überlegungen zum Speicher
Der Coroutine-Frame wird standardmäßig auf dem Heap reserviert. Der Compiler kann die Reservierung vermeiden, wenn Inlining dies erlaubt – messen Sie, wenn die Leistung wichtig ist.
Bibliotheken zum Erkunden
Zum Lernen bietet cppcoro von Lewis Baker gut dokumentierte Generator- und Task-Typen. Boost.Asio stellt Coroutine-freundliches I/O bereit. Ab C++23 gibt es Unterstützung in der Standardbibliothek.
Kurze Überprüfung
Wie lautet der Typ der C++23-Standardbibliothek für Generator-Coroutines?
Zusammenfassung
Eine Generator-Coroutine liefert mit co_yield verzögert Werte. Implementieren Sie sie mit einer Klasse, die einen promise_type enthält. C++23 hat std::generator standardisiert. Generatoren eignen sich besonders für verzögerte Sequenzen und Streaming.
Häufig gestellte Fragen
Ist die Lektion „Einen einfachen Generator implementieren“ kostenlos?
Ja — der vollständige Text von „Einen einfachen Generator implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Einen einfachen Generator implementieren“?
Erstellen Sie eine Generator-Coroutine, die Werte verzögert liefert. Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C++ Academy zu starten?
Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Einen einfachen Generator implementieren“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?
Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Coroutine-Konzepte: co_await, co_yield, co_return
- Einen einfachen Generator implementieren
- Asynchrone Aufgaben und Awaiter-Typen
- Speicherzuweisung für Coroutine-Frames