Namespaces
Variants

std:: generator

From cppreference.net
C++
Utilities library
Coroutine support
Coroutine traits
(C++20)
Coroutine handle
(C++20)
No-op coroutines
(C++20)
(C++20)
Trivial awaitables
(C++20)
(C++20)
Range generators
generator
(C++23)
Ranges library
Range adaptors
std::generator
Definiert im 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 Coroutine erzeugt werden.
2) Bequemlichkeits-Alias-Template für den generator unter Verwendung des polymorphic allocator .

Ein std::generator erzeugt eine Sequenz von Elementen durch wiederholtes Fortsetzen der Coroutine, von der es zurückgegeben wurde. Jedes Mal, wenn eine co_yield -Anweisung ausgewertet wird, produziert die Coroutine 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.

Inhaltsverzeichnis

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.

Datenmitglieder

Mitglied Definition
active_ (privat)

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

  • Wenn begin aufgerufen wird, wird ein neuer Stack erstellt und der Generator zum Stack hinzugefügt.
  • Wenn co_yield ranges :: elements_of ( rng ) in einem Generator-Körper ausgewertet wird, wird rng in einen Generator konvertiert und zum Stack hinzugefügt, der den umschließenden Generator enthält.
  • Wenn ein Generator-Iterator inkrementiert wird, wird die Coroutine an der Spitze des assoziierten Stacks fortgesetzt.
  • Wenn ein Generator abgeschlossen ist (d.h. wenn promise_type::final_suspend aufgerufen wird), wird er vom Stack entfernt.
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
coroutine_ (privat) ein Handle vom Typ std:: coroutine_handle < promise_type >
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

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 std::ranges::view_interface
gibt zurück, ob die abgeleitete View leer ist, bereitgestellt nur wenn sie sized_range oder forward_range erfüllt
(ö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 View nicht leer ist, bereitgestellt 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)