std::generator
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de 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 vista de los elementos producidos por la evaluación de una corrutina.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 rango rng 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 const volatile.
| ||
-reference es ya sea un tipo referencia o un tipo objeto no calificado const volatile que modela copy_constructible.
| ||
-Sea que RRef denote std::remove_reference_t<reference >&&, si reference es un tipo referencia, y reference de lo contrario.
|
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
|
coroutine_ (private)
|
Un identificador de tipo std::coroutine_handle<promise_type>(objeto miembro solo de exposición*) |
Funciones miembro
Construye un objeto generator. (función miembro pública) | |
Destruye efectivamente toda la pila de generators producidos. (función miembro pública) | |
Asigna un objeto generator. (función miembro pública) | |
| Reanuda la corrutina suspendida inicialmente y devuelve un iterador a su identificador. (función miembro pública) | |
| Devuelve std::default_sentinel. (función miembro pública) | |
Heredadas de ranges::view_interface | |
(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>)
|
(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
| El tipo promesa. (clase miembro pública) | |
| 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
(C++20) |
Crea un identificador de corrutina que no tiene efectos observables cuando se reanuda o destruye (función) |
