Namespaces
Variants

    std::generator

    Von de.cppreference.net
     
    C++
     
    Dienstprogramm-Bibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutine-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreifachvergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Koroutine-Unterstützung
    Koroutine-Eigenschaften
    (C++20)
    Koroutine-Handle
    (C++20)
    Noop-Koroutinen
    (C++20)
    (C++20)
    Triviale Awaitables
    (C++20)
    (C++20)
    Range-Generatoren
    (C++23)
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::generator
     
    Definiert in Header <generator> 
    template<
    class Ref,
    class V = void,
    class Allocator = void >
class generator
    : public ranges::view_interface<generator<Ref, V, Allocator>>
    		(1) (seit C++23) 
    namespace pmr {
    template< class Ref, class V = void >
    using generator =
        std::generator<Ref, V, std::pmr::polymorphic_allocator<>>;
}
    		(2) (seit C++23)
    1) Die Klassenvorlage std::generator stellt eine view der Elemente dar, die durch die Auswertung einer Koroutine geliefert werden.
    2) Bequeme Aliasvorlage für den generator unter Verwendung des polymorphen Allokators.

    Ein std::generator erzeugt eine Sequenz von Elementen, indem die Koroutine, von der es zurückgegeben wurde, wiederholt fortgesetzt wird. Jedes Mal, wenn eine co_yield-Anweisung ausgewertet wird, erzeugt die Koroutine ein Element der Sequenz. Wenn die co_yield-Anweisung die Form co_yield ranges::elements_of(rng) hat, wird jedes Element des range rng nacheinander als Element der Sequenz erzeugt.

    std::generator modelliert view und input_range.

    Das Verhalten eines Programms, das eine Spezialisierung für std::generator hinzufügt, ist undefiniert.

    Template-Parameter

    Ref - der Referenztyp ( ranges::range_reference_t ) des Generators. Wenn V void ist, werden sowohl der Referenztyp als auch der Werttyp von Ref abgeleitet
    V - der Werttyp ( ranges::range_value_t ) des Generators, oder void
    Allocator - ein Allokatortyp oder void

    Wenn Allocator nicht void ist, dann ist das Verhalten undefiniert, falls Allocator nicht die Allocator -Anforderungen erfüllt.

    Mitgliedertypen

    Mitglied Definition
    value (privat) std:: conditional_t < std:: is_void_v < V > , std:: remove_cvref_t < Ref > , V > ;
    ( Nur zur Darstellung verwendeter Mitgliedstyp* )
    reference (privat) std:: conditional_t < std:: is_void_v < V > , Ref && , Ref > ;
    ( Nur zur Darstellung verwendeter Mitgliedstyp* )
    yielded std:: conditional_t < std:: is_reference_v < reference  > , reference , const reference  & >
    Typanforderungen
    -
    std:: allocator_traits < Allocator > :: pointer ist ein Zeigertyp.
    -
    value ist ein cv-unqualifizierter Objekttyp.
    -
    reference ist entweder ein Referenztyp oder ein cv-unqualifizierter Objekttyp, der copy_constructible modelliert.
    -
    Sei RRef definiert als std:: remove_reference_t < reference  > && , falls reference ein Referenztyp ist, andernfalls als reference .

    Das Programm ist fehlerhaft, wenn eine dieser Typanforderungen nicht erfüllt ist.

    Datenelemente

    Element Beschreibung
    active_ (privat)

    Intern ist jede aktive Instanz von std::generator mit einem Stapel verbunden (behandelt, als ob durch ein Objekt vom Typ std::unique_ptr<std::stack<std::coroutine_handle<>>>).

    • Wenn begin aufgerufen wird, wird ein neuer Stapel erstellt und der Generator zum Stapel hinzugefügt.
    • Wenn co_yield ranges::elements_of(rng) in einem Generatorrumpf ausgewertet wird, wird rng in einen Generator umgewandelt und zum Stapel hinzugefügt, der den umschließenden Generator enthält.
    • Wenn ein Generator-Iterator erhöht wird, wird die Coroutine an der Spitze des zugehörigen Stapels fortgesetzt.
    • Wenn ein Generator beendet ist (d. h. wenn promise_type::final_suspend aufgerufen wird), wird er vom Stapel entfernt.
      (nur zur Darstellung dienendes Member-Objekt*)
    coroutine_ (privat) ein Handle vom Typ std::coroutine_handle<promise_type>
    (nur zur Darstellung dienendes Member-Objekt*)

    Memberfunktionen

    		konstruiert ein generator -Objekt
    (öffentliche Elementfunktion)
    		zerstört effektiv den gesamten Stack der ge-yieldeten generator s
    (öffentliche Elementfunktion)
    		weist ein generator -Objekt zu
    (öffentliche Elementfunktion)
    		setzt die anfänglich suspendierte Coroutine fort und gibt einen Iterator zu ihrem Handle zurück
    (öffentliche Elementfunktion)
    		gibt std::default_sentinel zurück
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur wenn sie sized_range oder forward_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Anfang des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Ansicht nicht leer ist, nur wenn ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    Geschachtelte Klassen

    		der Promise-Typ
    (öffentliche Member-Klasse)
    		der Iterator-Typ
    ( Nur zur Darstellung dienende Member-Klasse* )

    Hinweise

    Feature-Test Makro Wert Std Funktion
    __cpp_lib_generator 202207L (C++23) std::generator – synchroner Coroutine Generator für Ranges

    Beispiel

    Diesen Code ausführen 
    #include <generator>
#include <iostream>
template<typename T>
struct Tree
{
    T value;
    Tree *left{}, *right{};
    std::generator<const T&> traverse_inorder() const
    {
        if (left)
            co_yield std::ranges::elements_of(left->traverse_inorder());
        co_yield value;
        if (right)
            co_yield std::ranges::elements_of(right->traverse_inorder());
    }
};
int main()
{
    Tree<char> tree[]
    {
                                    {'D', tree + 1, tree + 2},
        //                            │
        //            ┌───────────────┴────────────────┐
        //            │                                │
                    {'B', tree + 3, tree + 4},       {'F', tree + 5, tree + 6},
        //            │                                │
        //  ┌─────────┴─────────────┐      ┌───────────┴─────────────┐
        //  │                       │      │                         │
          {'A'},                  {'C'}, {'E'},                    {'G'}
    };
    for (char x : tree->traverse_inorder())
        std::cout << x << ' ';
    std::cout << '\n';
}

    Ausgabe: 

    A B C D E F G

    Referenzen

    • C++23-Standard (ISO/IEC 14882:2024):
    • 26.8 Bereichsgeneratoren [coro.generator]

    Siehe auch

    (C++20)
    		Erstellt ein Coroutine-Handle, das bei Wiederaufnahme oder Zerstörung keine beobachtbaren Effekte hat
    (Funktion)