Namespaces
Variants

std::ranges:: views:: enumerate, std::ranges:: enumerate_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::enumerate_view
Member functions
(C++26)
Deduction guides
Nested classes
Iterator
Sentinel
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 /* no especificado */ enumerate = /* no especificado */ ;

}
(2) (desde C++23)
Firma de llamada
template < ranges:: viewable_range R >

requires /* ver más abajo */

constexpr /* ver más abajo */ 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 para exposición* )
1) enumerate_view es un adaptador de rango que toma una view y produce una vista de tuple s. El elemento i th (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-expresión a enumerate_view < views:: all_t < decltype ( ( e ) ) >> ( e ) para cualquier subexpresión adecuada e .
3) Garantiza que el tipo de referencia del tipo subyacente pueda ser movido.

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 respectivos conceptos.

Contenidos

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 std::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 >> =

ranges:: enable_borrowed_range < 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)
(C++20)
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)