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
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) (depuis C++23)
namespace pmr {

template < class Ref, class V = void >
using generator =
std :: generator < Ref, V, std:: pmr :: polymorphic_allocator <>> ;

}
(2) (depuis 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 commodité pour le generator utilisant l' allocateur polymorphe .

Un std::generator génère une séquence d'éléments en reprenant à plusieurs reprises la coroutine à partir de laquelle il a été retourné. Chaque fois qu'une instruction co_yield est évaluée, la coroutine produit un élément de la séquence. Lorsque l'instruction co_yield est de la forme co_yield ranges :: elements_of ( rng ) , chaque élément de la range rng est successivement produit comme é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.

Table des matières

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 Définition
active_ (privé)

En interne, chaque instance active de std::generator est associée à une pile (gérée comme si 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 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 au sommet 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 std::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 un 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)