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
Definido en el encabezado <generator>
template <

class Ref,
class V = void ,
class Allocator = void >
class generator

: public ranges:: view_interface < generator < Ref, V, Allocator >>
(1) (desde C++23)
namespace pmr {

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

}
(2) (desde C++23)
1) La plantilla de clase std::generator presenta una view de los elementos producidos por la evaluación de una coroutine .
2) Plantilla de alias de conveniencia para el generator que utiliza el polymorphic allocator .

Un std::generator genera una secuencia de elementos al reanudar repetidamente la corrutina desde la cual fue devuelto. Cada vez que se evalúa una sentencia co_yield , la corrutina produce un elemento de la secuencia. Cuando la sentencia co_yield tiene la forma co_yield ranges :: elements_of ( rng ) , cada elemento del range rng se produce sucesivamente como un elemento de la secuencia.

std::generator modela view y input_range .

El comportamiento de un programa que añade una especialización para std::generator no está definido.

Contenidos

Parámetros de plantilla

Ref - el tipo de referencia ( ranges::range_reference_t ) del generador. Si V es void , tanto el tipo de referencia como el tipo de valor se infieren de Ref
V - el tipo de valor ( ranges::range_value_t ) del generador, o void
Allocator - un tipo de asignador o void

Si Allocator no es void , entonces el comportamiento es indefinido si Allocator no cumple con los requisitos de Allocator .

Tipos de miembros

Miembro Definición
value (privado) std:: conditional_t < std:: is_void_v < V > , std:: remove_cvref_t < Ref > , V > ;
( tipo de miembro solo para exposición* )
reference (privado) std:: conditional_t < std:: is_void_v < V > , Ref && , Ref > ;
( tipo de miembro solo para exposición* )
yielded std:: conditional_t < std:: is_reference_v < reference  > , reference , const reference  & >
Requisitos de tipo
-
std:: allocator_traits < Allocator > :: pointer es un tipo puntero.
-
value es un tipo objeto sin calificadores cv.
-
reference es un tipo referencia, o un tipo objeto sin calificadores cv que modela copy_constructible .
-
Sea RRef que denota std:: remove_reference_t < reference  > && , si reference es un tipo referencia, y reference en caso contrario.

El programa está mal formado si no se satisface alguno de estos requisitos de tipo.

Miembros de datos

Miembro Definición
active_ (privado)

Internamente, cada instancia activa de std::generator está asociada con una pila (manejada como si fuera por un objeto de tipo std:: unique_ptr < std:: stack < std:: coroutine_handle <>>> ).

  • Cuando se llama a begin , se crea una nueva pila y el generador se añade a la pila.
  • Cuando se evalúa co_yield ranges :: elements_of ( rng ) en el cuerpo de un generador, rng se convierte en un generador y se añade a la pila que contiene el generador envolvente.
  • Cuando un iterador de generador se incrementa , se reanuda la corrutina en la parte superior de la pila asociada.
  • Cuando un generador finaliza (es decir, cuando se llama a promise_type::final_suspend ), se elimina de la pila.
    ( objeto miembro solo para exposición* )
coroutine_ (privado) un manejador de tipo std:: coroutine_handle < promise_type >
( objeto miembro solo para exposición* )

Funciones miembro

construye un objeto generator
(función miembro pública)
destruye efectivamente toda la pila de generator s producidos
(función miembro pública)
asigna un objeto generator
(función miembro pública)
reanuda la corrutina inicialmente suspendida y devuelve un iterador a su manejador
(función miembro pública)
devuelve std::default_sentinel
(función miembro pública)
Heredado de std::ranges::view_interface
indica si la vista derivada está vacía, proporcionado solo si satisface sized_range o forward_range
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un iterador constante al inicio del rango
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un centinela para el iterador constante del rango
(función miembro pública de std::ranges::view_interface<D> )
indica si la vista derivada no está vacía, proporcionado solo si ranges::empty es aplicable a ella
(función miembro pública de std::ranges::view_interface<D> )

Clases anidadas

el tipo promise
(clase miembro pública)
el tipo iterador
( clase miembro solo para exposición* )

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_generator 202207L (C++23) std::generator – generador síncrono de corrutinas para rangos

Ejemplo

Ejecutar este código 
#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';
}

Salida: 

A B C D E F G

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 26.8 Generadores de rango [coro.generator]

Véase también

(C++20)
crea un manejador de corrutina que no tiene efectos observables cuando se reanuda o se destruye
(función)