Namespaces
Variants

    std::generator

    Depuis fr.cppreference.net
     
    C++
    Prise en charge du compilateur
    Autonome et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support du langage
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (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)

    Utilitaires généraux
    Opérateurs relationnels (déprécié en C++20)
    Fonctions de comparaison d'entiers
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap et opérations de type
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Types de vocabulaire courants
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Support des coroutines
    Traits de coroutine
    (C++20)
    Gestionnaire de coroutine
    (C++20)
    Coroutines inactives
    (C++20)
    (C++20)
    Attendables triviaux
    (C++20)
    (C++20)
    Générateurs de plages
    (C++23)
     
    Bibliothèque de plages
    Adaptateurs de plages
     
    std::generator
     
    Défini dans l'en-tête <generator> 
    template<
    class Ref,
    class V = void,
    class Allocator = void >
class generator
    : public ranges::view_interface<generator<Ref, V, Allocator>>
    		(1) (since C++23) 
    namespace pmr {
    template< class Ref, class V = void >
    using generator =
        std::generator<Ref, V, std::pmr::polymorphic_allocator<>>;
}
    		(2) (since C++23)
    1) Le modèle de classe std::generator présente une view des éléments produits par l'évaluation d'une coroutine.
    2) Alias de modèle de commodité pour le generator utilisant l'allocateur polymorphe.

    Un std::generator génère une séquence d'éléments en reprenant de manière répétée la coroutine à partir de laquelle il a été retourné. Chaque fois qu'une co_yield instruction est évaluée, la coroutine produit un élément de la séquence. Lorsque l'co_yield instruction est de la forme co_yield ranges::elements_of(rng), chaque élément du range rng est produit successivement comme un élément de la séquence.

    std::generator modélise view et input_range.

    Le comportement d'un programme qui ajoute une spécialisation pour std::generator est indéfini.

    Paramètres du modèle

    Ref - le type de référence ( ranges::range_reference_t ) du générateur. Si V est void , le type de référence et le type de valeur sont déduits de Ref
    V - le type de valeur ( ranges::range_value_t ) du générateur, ou void
    Allocator - un type d'allocateur ou void

    Si Allocator n'est pas void , alors le comportement est indéfini si Allocator ne satisfait pas aux Allocator exigences.

    Types membres

    Membre Définition
    value (privé) std:: conditional_t < std:: is_void_v < V > , std:: remove_cvref_t < Ref > , V > ;
    ( type membre d'exposition uniquement* )
    reference (privé) std:: conditional_t < std:: is_void_v < V > , Ref && , Ref > ;
    ( type membre d'exposition uniquement* )
    yielded std:: conditional_t < std:: is_reference_v < reference  > , reference , const reference  & >
    Exigences de type
    -
    std:: allocator_traits < Allocator > :: pointer est un type pointeur.
    -
    value est un type d'objet non qualifié cv.
    -
    reference est soit un type référence, soit un type d'objet non qualifié cv qui modélise copy_constructible .
    -
    Soit RRef dénotant std:: remove_reference_t < reference  > && , si reference est un type référence, et reference sinon.

    Le programme est mal formé si l'une de ces exigences de type n'est pas satisfaite.

    Membres de données

    Membre Description
    active_ (privé)

    En interne, chaque instance active de std::generator est associée à une pile (gérée comme par un objet de type std::unique_ptr<std::stack<std::coroutine_handle<>>>).

    • Lorsque begin est appelé, une nouvelle pile est créée et le générateur est ajouté à la pile.
    • Lorsque co_yield ranges::elements_of(rng) est évalué dans un corps de générateur, rng est converti en un générateur et ajouté à la pile qui contient le générateur englobant.
    • Lorsqu'un itérateur de générateur est incrémenté, la coroutine en haut de la pile associée est reprise.
    • Lorsqu'un générateur se termine (c'est-à-dire lorsque promise_type::final_suspend est appelé), il est retiré de la pile.
      (objet membre d'exposition uniquement*)
    coroutine_ (privé) un handle de type std::coroutine_handle<promise_type>
    (objet membre d'exposition uniquement*)

    Fonctions membres

    		construit un objet generator
    (fonction membre publique)
    		détruit effectivement toute la pile des generator s générés
    (fonction membre publique)
    		assigne un objet generator
    (fonction membre publique)
    		reprend la coroutine initialement suspendue et retourne un itérateur vers son handle
    (fonction membre publique)
    		retourne std::default_sentinel
    (fonction membre publique)
    Hérité de ranges::view_interface
    		retourne si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
    (fonction membre publique de std::ranges::view_interface<D>)
    (C++23)
    		 retourne un itérateur constant vers le début de la plage
    (fonction membre publique de std::ranges::view_interface<D>)
    (C++23)
    		 retourne une sentinelle pour l'itérateur constant de la plage
    (fonction membre publique de std::ranges::view_interface<D>)
    		retourne si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
    (fonction membre publique de std::ranges::view_interface<D>)

    Classes imbriquées

    		le type de promesse
    (classe membre publique)
    		le type d'itérateur
    ( classe membre à titre d'illustration uniquement* )

    Notes

    Macro de test de fonctionnalité Valeur Norme Fonctionnalité
    __cpp_lib_generator 202207L (C++23) std::generator – générateur synchrone de coroutine pour les ranges

    Exemple

    Exécuter ce code 
    #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';
}

    Sortie : 

    A B C D E F G

    Références

    • Standard C++23 (ISO/IEC 14882:2024) :
    • 26.8 Générateurs de plages [coro.generator]

    Voir aussi

    (C++20)
    		crée un gestionnaire de coroutine qui n'a aucun effet observable lors de la reprise ou de la destruction
    (fonction)