PricingLoginStart free
C++ Academy · leksjon

Implementering av en enkel generator

Bygg en generator-coroutine som gir verdier på en lat måte.

Leksjon 2 av 414 trinn

Implementering av en enkel generator er en gratis leksjon i C++ Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C++ Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C++ Academy inneholder totalt 4 leksjoner.

Generatorer som coroutine-er

En generator er en coroutine som gir én verdi om gangen. Hvert kall til generatoren produserer den neste verdien og setter kjøringen på pause.

Generatortypen

Definer en klasse med en nestet promise_type. Kompilatoren bruker den til å håndtere tilstanden til coroutine-en.

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() ...
};

Bruke generatoren

Når den er definert, føles generatorer som Python yield.

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 4

coroutine_handle

Kompilatoren returnerer en std::coroutine_handle. Den representerer den suspenderte coroutine-en — du kan kalle resume(), destroy() eller kontrollere done().

Pausepunkter

Hver co_yield setter kjøringen på pause. Når kalleren kaller resume(), fortsetter kjøringen til neste pausepunkt eller til coroutine-en avsluttes.

initial_suspend og final_suspend

To tilpasningspunkter:

  • initial_suspend — returner suspend_always for en lat start, eller suspend_never for en ivrig start
  • final_suspend — styrer oppryddingen. Vanligvis brukes suspend_always for korrekt destruksjon

C++23 std::generator

C++23 la til std::generator i <generator>. Du trenger ikke lenger å implementere typen selv i vanlige tilfeller.

#include <generator>

std::generator<int> counting() {
    int n = 0;
    while (true) co_yield n++;
}

Range-basert for

Hvis generatortypen støtter begin/end, fungerer range-basert for direkte.

for (int x : counting()) {
    if (x >= 10) break;
    std::cout << x;
}

Pull- kontra push-semantikk

Generatorer er pull-baserte — kalleren styrer iterasjonen. Push-baserte coroutine-er er asynkrone oppgaver.

Bruksområder

Generatorer er godt egnet for:

  • Late sekvenser (Fibonacci, primtall, fillesere linje for linje)
  • Strømming av data uten materialisering
  • Iterering gjennom trelignende strukturer

Minnehensyn

Coroutine-rammeverket allokeres som standard på heapen. Kompilatoren kan utelate allokeringen når inlining tillater det — mål ytelsen når den er viktig.

Biblioteker du kan utforske

For læring har cppcoro av Lewis Baker godt dokumenterte generator- og oppgavetyper. Boost.Asio tilbyr I/O som er tilpasset coroutine-er. Fra og med C++23 får du støtte i standardbiblioteket.

Rask kontroll

Hva heter standardbibliotekstypen for generator-coroutine-er i C++23?

Besvar den i den interaktive leksjonen

Oppsummering

En generator-coroutine gir verdier lat ved hjelp av co_yield. Implementer den med en klasse som inneholder en promise_type. C++23 standardiserte std::generator. Generatorer egner seg svært godt for late sekvenser og strømming.

Gratis å komme i gang

Lær deg C++ med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
51
Leksjoner
203
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Implementering av en enkel generator» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien C++ Academy, inkludert «Implementering av en enkel generator», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i C++ Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Implementering av en enkel generator»?

Bygg en generator-coroutine som gir verdier på en lat måte. Du øver på C++ Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C++ Academy?

Ingen tidligere erfaring er nødvendig. C++ Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Implementering av en enkel generator»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C++ Academy-leksjonen?

Ja. Alle C++ Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Coroutine-konsepter: co_await, co_yield, co_return
  2. Implementering av en enkel generator
  3. Asynkrone oppgaver og awaiter-typer
  4. Allokering av coroutine-rammer
← Tilbake til C++ Academy