std::ranges::views::enumerate, std::ranges::enumerate_view
De es.cppreference.net
| Definido en el encabezado <ranges>
|
||
template< ranges::view V >
requires /*range-with-movable-references*/<V>
class enumerate_view
: public ranges::view_interface<enumerate_view<V>>
|
(1) | (desde C++23) |
namespace views {
inline constexpr /* unspecified */ enumerate = /* unspecified */;
}
|
(2) | (desde C++23) |
| Signatura de llamada |
||
template< ranges::viewable_range R >
requires /* see below */
constexpr /* see below */ enumerate( R&& r );
|
(desde C++23) | |
| Conceptos auxiliares |
||
template< class R >
concept /*range-with-movable-references*/ =
ranges::input_range<R> &&
std::move_constructible<ranges::range_reference_t<R>> &&
std::move_constructible<ranges::range_rvalue_reference_t<R>>;
|
(3) | (solo exposición*) |
1)
enumerate_view es un adaptador de rango que toma una vista y produce una vista de std::tuples. iésimo elemento (la tupla) de la secuencia resultante contiene:
- el valor igual a
i, que es un índice basado en cero del elemento de la secuencia subyacente, y - la referencia al elemento subyacente.
2) El nombre
views::enumerate denota un RangeAdaptorObject. Dada una subexpresión e, la expresión views::enumerate(e) es equivalente a la expresión enumerate_view<views::all_t<decltype((e))>>(e) para cualquier subexpresión adecuada e.3) Asegura que el tipo de referencia del tipo subyacente se pueda mover.
enumerate_view modela los conceptos random_access_range, bidirectional_range, forward_range, input_range, common_range y sized_range cuando la vista subyacente V modela los conceptos respectivos.
Miembros de datos
| Miembro | Descripción |
V
base_
|
un iterador al
view
subyacente
( miembro objeto solo para exposición* ) |
Funciones miembro
construye un
enumerate_view
(función miembro pública) |
|
|
devuelve una copia de la vista subyacente (adaptada)
(función miembro pública) |
|
|
devuelve un iterador al inicio
(función miembro pública) |
|
|
devuelve un iterador o un centinela al final
(función miembro pública) |
|
devuelve el número de elementos, proporcionado solo si el rango subyacente (adaptado) satisface
sized_range
(función miembro pública) |
|
|
(C++26)
|
devuelve el tamaño aproximado del
approximately_sized_range
resultante
(función miembro pública) |
Heredado de ranges::view_interface | |
| devuelve 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>)
|
| devuelve 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>)
| |
| devuelve el primer elemento en la vista derivada, proporcionado si satisface forward_range (función miembro pública de std::ranges::view_interface<D>)
| |
| devuelve el último elemento en la vista derivada, proporcionado solo si satisface bidirectional_range y common_range (función miembro pública de std::ranges::view_interface<D>)
| |
devuelve el nésimo elemento en la vista derivada, proporcionado solo si satisface random_access_range (función miembro pública de std::ranges::view_interface<D>)
| |
Guías de deducción
Clases anidadas
|
(C++23)
|
el tipo de iterador
( clase de plantilla miembro solo para exposición* ) |
|
(C++23)
|
el tipo de centinela
( clase de plantilla miembro solo para exposición* ) |
Plantillas auxiliares
|
template
<
class
View
>
constexpr
bool
enable_borrowed_range
<
ranges
::
enumerate_view
<
View
>>
=
|
(desde C++23) | |
Esta especialización de
ranges::enable_borrowed_range
hace que
enumerate_view
satisfaga
borrowed_range
cuando la vista subyacente lo satisface.
Notas
| Macro de prueba de características | Valor | Std | Característica |
|---|---|---|---|
__cpp_lib_ranges_enumerate
|
202302L
|
(C++23) |
std::ranges::enumerate_view
|
Ejemplo
Ejecutar este código
#include <initializer_list> #include <iostream> #include <map> #include <ranges> #include <vector> int main() { constexpr static auto v = {'A', 'B', 'C', 'D'}; for (auto const [index, letter] : std::views::enumerate(v)) std::cout << '(' << index << ':' << letter << ") "; std::cout << '\n'; #if __cpp_lib_ranges_to_container // crear un mapa usando la posición de cada elemento como clave auto m = v | std::views::enumerate | std::ranges::to<std::map>(); for (auto const [key, value] : m) std::cout << '[' << key << "]:" << value << ' '; std::cout << '\n'; #endif std::vector<int> numbers{1, 3, 5, 7}; // num es mutable incluso con const, lo cual no se propaga a la referencia // para hacerlo const, usar `std::views::enumerate(numbers) | std::views::as_const` // o `std::views::enumerate(std::as_const(numbers))` for (auto const [index, num] : std::views::enumerate(numbers)) { ++num; // el tipo es int& std::cout << numbers[index] << ' '; } std::cout << '\n'; }
Salida posible:
(0:A) (1:B) (2:C) (3:D) [0]:A [1]:B [2]:C [3]:D 2 4 6 8
Referencias
- Estándar C++23 (ISO/IEC 14882:2024):
-
- 26.7.23 Vista de enumeración [range.enumerate]
Véase también
|
(C++20)
|
una
view
que consiste en una secuencia generada incrementando repetidamente un valor inicial
(plantilla de clase) (objeto de punto de personalización) |
|
(C++23)
|
una
view
que consiste en tuplas de referencias a elementos correspondientes de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización) |
toma una
view
que consiste en valores
tuple-like
y un número N, y produce una
view
del N-ésimo elemento de cada tupla
(plantilla de clase) (objeto adaptador de rango) |