std::generator

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica(C++20) Servicios del programa Apoyo de corrutinas(C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits(C++20) bitset hash (C++11) Operadores relacionales(en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Apoyo de corrutinas

Rasgos de corrutinas

coroutine_traits (C++20)

Identificador de corrutina

coroutine_handle (C++20)

Corrutinas no operativas

noop_coroutine_promise (C++20)

noop_coroutine (C++20)

En espera triviales

suspend_never (C++20)

suspend_always (C++20)

 

Biblioteca de rangos

Acceso a rangos begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata empty

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Conceptos de rangos
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

std::generator

Funciones miembro

generator::generator

generator::~generator

generator::operator=

generator::begin

generator::end

promise_type

generator::promise_type::get_return_object

generator::promise_type::initial_suspend

generator::promise_type::final_suspend

generator::promise_type::yield_value

generator::promise_type::return_void

generator::promise_type::unhandled_exception

generator::promise_type::operator new

generator::promise_type::operator delete

Iterator

generator::iterator::iterator

generator::iterator::operator=

generator::iterator::operator*

generator::iterator::operator++ generator::iterator::operator++(int)

operator==(generator::iterator, std::default_sentinel_t)

 

Definido en el archivo de encabezado <generator>
template<     class Ref,     class V =void,     class Allocator =void> class generator     :publicranges::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 vista de los elementos producidos por la evaluación de una corrutina.

2) Alias de plantilla conveniente para que el generator use polymorphic allocator.

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

std::generator modela view e input_range.

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

Parámetros de plantilla

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

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

Tipos miembro

Miembro	Definición
value(private)	std::conditional_t<std::is_void_v<V>, std::remove_cvref_t<[[:Plantilla:void]]Ref>, V>; (tipo miembro solo de exposición*)
reference(private)	std::conditional_t<std::is_void_v<V>, Ref&&, Ref>; (tipo miembro solo de 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 no calificado constvolatile.

- reference es ya sea un tipo referencia o un tipo objeto no calificado constvolatile que modela copy_constructible.

- Sea que RRef denote std::remove_reference_t<reference >&&, si reference es un tipo referencia, y reference de lo contrario. Se modela std::common_reference_with<reference &&, value &>. Se modela std::common_reference_with<reference &&, RRef &&>. Se modela std::common_reference_with<RRef &&, const value &>.

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

Datos miembro

Miembro	Definición
active_(private)	Internamente, cada instancia activa de std::generator está asociada con una pila (manejada como si fuera 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 a co_yield ranges::elements_of(rng) en el cuerpo de un generador, rng se convierte a un generador y se añade a la pila que contiene el generador circundante. Cuando un iterador de generador se incrementa, se reanuda la corrutina en la parte superior de la pila asociada. Cuando un generador termina (p. ej., cuando se llama a promise_type::final_suspend), se elimina de la pila. (objeto miembro solo de exposición*)
coroutine_(private)	Un identificador de tipo std::coroutine_handle<promise_type> (objeto miembro solo de exposición*)

Funciones miembro

(constructor)	Construye un objeto generator. (función miembro pública)
(destructor)	Destruye efectivamente toda la pila de generators producidos. (función miembro pública)
operator=	Asigna un objeto generator. (función miembro pública)
begin	Reanuda la corrutina suspendida inicialmente y devuelve un iterador a su identificador. (función miembro pública)
end	Devuelve std::default_sentinel. (función miembro pública)
Heredadas de std::ranges::view_interface
empty (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
operator bool (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si ranges::empty le es aplicable. (función miembro pública de std::ranges::view_interface<D>)

Clases anidadas

promise_type	El tipo promesa. (clase miembro pública)
iterator	El tipo iterador. (clase miembro de solo exposición)

Notas

Macro de Prueba de característica	Valor	Estándar	Comentario
__cpp_lib_generator	202207L	(C++23)	std::generator – Generador de corrutina síncrono para rangos.

Ejemplo

Ejecuta 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

• El estándar C++23 (ISO/IEC 14882:2023):

• 26.8 Generadores de rangos [coro.generator]

Véase también

noop_coroutine (C++20)

Crea un identificador de corrutina que no tiene efectos observables cuando se reanuda o destruye (función)