Biblioteca de rangos (C++20)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Encabezados de la biblioteca estándar

Requerimientos denominados

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

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de metaprogramación (C++11)

Biblioteca de diagnósticos

Biblioteca de utilerías generales

Biblioteca de cadenas

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca numérica

Biblioteca de localizaciones

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de expresiones regulares (C++11)

Biblioteca de apoyo de concurrencia (C++11)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de rangos

Acceso a rangos
begin cbegin end cend	rbegin crbegin rend crend	size ssize data cdata	empty
Primitivas de rangos
iterator_tsentinel_t	range_size_trange_difference_t	range_reference_trange_rvalue_reference_t	range_value_t
Manejo de iteradores pendientes
dangling	borrowed_iterator_t	borrowed_subrange_t
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
Vistas
view_interface	subrange
Fábricas
empty_viewviews::empty	single_viewviews::single	iota_viewviews::iota	basic_istream_viewviews::istream
Adaptadores
views::all_tviews::all ref_view owning_view common_viewviews::common reverse_viewviews::reverse views::counted zip_viewviews::zip (C++23)(C++23)	take_viewviews::take take_while_viewviews::take_while drop_viewviews::drop drop_while_viewviews::drop_while zip_transform_viewviews::zip_transform (C++23)(C++23)	elements_viewviews::elements keys_viewviews::keys values_viewviews::values transform_viewviews::transform adjacent_viewviews::adjacent (C++23)(C++23)	filter_viewviews::filter join_viewviews::join split_viewviews::split lazy_split_viewviews::lazy_split adjacent_transform_viewviews::adjacent_transform (C++23)(C++23)
Objetos adaptadores de rango
Objetos cierre adaptadores de rango
Elementos auxiliares
copyable-box	simple-view

 

La biblioteca de rangos proporciona componentes para tratar con rangos de elementos, incluyendo una variedad de adaptadores de vistas.

Definido en el archivo de encabezado <ranges>
namespace std {     namespace views = ranges::views; }

El alias de espacio de nombres std::views se proporciona como una notación abreviada de std::ranges::views.

Definido en el espacio de nombres std::ranges
Acceso a rangos
Definido en el archivo de encabezado <ranges>
Definido en el archivo de encabezado <iterator>
ranges::begin (C++20)	Devuelve un iterador al principio de un rango. (objeto de punto de personalización)
ranges::end (C++20)	Devuelve un iterador al final de un rango (objeto de punto de personalización)
ranges::cbegin (C++20)	Devuelve un iterador al inicio de un rango de solo lectura. (objeto de punto de personalización)
ranges::cend (C++20)	Devuelve un centinela que indica el fin de un rango de solo lectura (objeto de punto de personalización)
ranges::rbegin (C++20)	Devuelve un iterador inverso a un rango (objeto de punto de personalización)
ranges::rend (C++20)	Devuelve un iterador final inverso a un rango (objeto de punto de personalización)
ranges::crbegin (C++20)	Devuelve un iterador inverso a un rango de solo lectura (objeto de punto de personalización)
ranges::crend (C++20)	Devuelve un iterador inverso al final de un rango de solo lectura (objeto de punto de personalización)
ranges::size (C++20)	Obtiene el tamaño de un rango cuyo tamaño puede calcularse en tiempo constante. (objeto de punto de personalización)
ranges::ssize (C++20)	Obtiene el tamaño de un rango cuyo tamaño puede calcularse en tiempo constante y lo convierte a un entero con signo. (objeto de punto de personalización)
ranges::empty (C++20)	Comprueba si un rango está vacío. (objeto de punto de personalización)
ranges::data (C++20)	Obtiene un puntero al principio de un rango contiguo (objeto de punto de personalización)
ranges::cdata (C++20)	Obtiene un puntero al inicio de un rango contiguo de solo lectura (objeto de punto de personalización)
Primitivas de rangos
Definido en el archivo de encabezado <ranges>
ranges::iterator_tranges::sentinel_tranges::range_difference_tranges::range_size_t ranges::range_value_tranges::range_reference_tranges::range_rvalue_reference_t (C++20)	Obtiene los tipos asociados de un rango. (plantilla de alias)
Manejo de iteradores pendientes
Definido en el archivo de encabezado <ranges>
ranges::dangling (C++20)	Un tipo marcador de posición que indica que un iterador o un subrango (subrange) no debe devolverse ya que quedaría pendiente. (clase)
ranges::borrowed_iterator_tranges::borrowed_subrange_t (C++20)	Obtiene el tipo iterador o tipo subrango (subrange) de un rango prestado (borrowed_range). (plantilla de alias)
Conceptos de rangos
Definido en el archivo de encabezado <ranges>
ranges::range (C++20)	Especifica que un tipo es un rango. Es decir, proporciona un iterador begin y un centinela end. (concepto)
ranges::borrowed_range (C++20)	Especifica que un tipo es un rango (range) e iteradores obtenidos a partir de una expresión de él pueden devolverse de forma segura sin peligro de que queden pendientes. (concepto)
ranges::sized_range (C++20)	Especifica que un rango conoce su tamaño en tiempo constante. (concepto)
ranges::view (C++20)	Especifica que un rango es una vista. Es decir, tiene un tiempo de copia, movimiento y asignación constante. (concepto)
ranges::input_range (C++20)	Especifica un rango cuyo tipo iterador satisface input_iterator. (concepto)
ranges::output_range (C++20)	Especifica un rango cuyo tipo iterador satisface output_iterator. (concepto)
ranges::forward_range (C++20)	Especifica un rango cuyo tipo iterador satisface forward_iterator (concepto)
ranges::bidirectional_range (C++20)	Especifica un rango cuyo tipo iterador satisface bidirectional_iterator. (concepto)
ranges::random_access_range (C++20)	Especifica un rango cuyo tipo iterador satisface random_access_iterator. (concepto)
ranges::contiguous_range (C++20)	Especifica un rango cuyo tipo iterador satisface contiguous_iterator. (concepto)
ranges::common_range (C++20)	Especifica que un rango tiene tipos iterador y centinela idénticos. (concepto)
ranges::viewable_range (C++20)	Especifica los requerimientos para que un rango (range) sea convertible de manera segura a una vista (view). (concepto)
Vistas
Definido en el archivo de encabezado <ranges>
ranges::view_interface (C++20)	Plantilla de clase auxiliar para definir una vista (view), usando el patrón de plantilla curiosamente recurrente (CRTP). (plantilla de clase)
ranges::subrange (C++20)	Combina un par iterador-centinela en una vista (view). (plantilla de clase)

Fábricas de rangos

Definido en el archivo de encabezado <ranges>
Definido en el espacio de nombres std::ranges
ranges::empty_viewviews::empty (C++20)	Una vista (view) sin elementos. (plantilla de clase) (plantilla de variables)
ranges::single_viewviews::single (C++20)	Una vista (view) que contiene un solo elemento de un valor específico. (plantilla de clase) (objeto de punto de personalización)
ranges::iota_viewviews::iota (C++20)	Una vista (view) que consiste en una secuencia generada al incrementar repetidamente un valor inicial. (plantilla de clase) (objeto de punto de personalización)
ranges::basic_istream_viewviews::istream (C++20)	Una vista (view) que consiste en los elementos obtenidos mediante la aplicación sucesiva del operador de extracción (operator>>) sobre el flujo de entrada asociado. (plantilla de clase) (objeto de punto de personalización)

Adaptadores de rangos

Definido en el archivo de encabezado <ranges>
Definido en el espacio de nombres std::ranges
views::all_tviews::all (C++20)	Una vista (view) que incluye todos los elementos de un rango (range). (plantilla de alias) (objeto adaptador de rango)
ranges::ref_view (C++20)	Una vista (view) de los elementos de algún otro rango (range). (plantilla de clase)
ranges::owning_view (C++20)	Una vista (view) con propiedad única de algún rango (range). (plantilla de clase)
ranges::filter_viewviews::filter (C++20)	Una vista (view) que consiste en los elementos de un rango (range) que satisface un predicado. (plantilla de clase) (objeto adaptador de rango)
ranges::transform_viewviews::transform (C++20)	Una vista (view) de una secuencia que aplica una función de transformación a cada elemento. (plantilla de clase) (objeto adaptador de rango)
ranges::take_viewviews::take (C++20)	Una vista (view) que consiste de los primeros N elementos de otra vista. (plantilla de clase) (objeto adaptador de rango)
ranges::take_while_viewviews::take_while (C++20)	Una vista (view) que consiste en los elementos iniciales de otra vista, hasta el primer elemento sobre el que un predicado devuelva falso. (plantilla de clase) (objeto adaptador de rango)
ranges::drop_viewviews::drop (C++20)	Una vista (view) que consiste en los elementos de otra vista, saltándose los primeros N elementos. (plantilla de clase) (objeto adaptador de rango)
ranges::drop_while_viewviews::drop_while (C++20)	Una vista (view) que consiste en los elementos de otra vista, saltándose la subsecuencia inicial de elementos hasta el primer elemento donde el predicado devuelva falso. (plantilla de clase) (objeto adaptador de rango)
ranges::join_viewviews::join (C++20)	Una vista (view) que consiste en la secuencia obtenida al aplanar una vista de rangos (range). (plantilla de clase) (objeto adaptador de rango)
ranges::split_viewviews::split (C++20)	Una vista (view) sobre los subrangos obtenidos al dividir otra vista usando un delimitador. (plantilla de clase) (objeto adaptador de rango)
ranges::lazy_split_viewviews::lazy_split (C++20)	Una vista (view) sobre los subrangos obtenidos al separar otra vista (view) usando un delimitador. (plantilla de clase) (objeto adaptador de rango)
views::counted (C++20)	Crea un subrango a partir de un iterador y una cuenta. (objeto de punto de personalización)
ranges::common_viewviews::common (C++20)	Convierte una vista (view) a un rango común (common_range). (plantilla de clase) (objeto adaptador de rango)
ranges::reverse_viewviews::reverse (C++20)	Una vista (view) que itera sobre los elementos de otra vista bidirectional en orden inverso. (plantilla de clase) (objeto adaptador de rango)
ranges::elements_viewviews::elements (C++20)	Toma una vista (view) que consiste en valores similares a tuplas y a un número N y produce una vista del N-ésimo elemento de cada tupla. (plantilla de clase) (objeto adaptador de rango)
ranges::keys_viewviews::keys (C++20)	Toma una vista (view) que consiste en valores similares a pares y produce una vista de los primeros elementos de cada par. (plantilla de clase) (objeto adaptador de rango)
ranges::values_viewviews::values (C++20)	Toma una vista (view) que consiste valores similares a pares y produce una vista de los segundos elementos de cada par. (plantilla de clase) (objeto adaptador de rango)
ranges::zip_viewviews::zip (C++23)	Una vista (view) que consiste en tuplas o referencias a elementos correspondientes de las vistas adaptadas. (plantilla de clase) (objeto de punto de personalización)
ranges::zip_transform_viewviews::zip_transform (C++23)	Una vista (view) que consiste en tuplas del resultado de aplicar una función de transformación a los elementos correspondientes de las vistas adaptadas. (plantilla de clase) (objeto de punto de personalización)
ranges::adjacent_viewviews::adjacent (C++23)	Una vista (view) que consiste en tuplas de referencias a elementos adyacentes de la vista adaptada. (plantilla de clase) (objeto adaptador de rango)
ranges::adjacent_transform_viewviews::adjacent_transform (C++23)	Una vista (view) que consiste en tuplas del resultado de aplicar una función de transformación a elementos adyacentes de la vista adaptada. (plantilla de clase) (objeto adaptador de rango)

Algunos adaptadores de rango envuelven sus elementos u objetos función con el envoltorio copiable.

Objetos adaptadores de rango

Los objetos adaptadores de rango son objetos de punto de personalización que aceptan un rango visible (viewable_range) como sus primeros argumentos y devuelven una vista (view). Algunos adaptadores de rango son unarios, es decir, toman un rango visible como su único argumento. Otros objetos adaptadores de rango toman un rango visible y otros argumentos al final.

Si un objeto adaptador de rango toma más de un argumento, también admite la aplicación parcial: sea

• a tal objeto adaptador de rango, y
• args... sean argumentos (generalmente adecuados como argumentos al final),

la expresión a(args...) tiene las siguientes propiedades:

• es válida si y solo si para cada argumento e en args... tal que E es decltype((e)), std::is_constructible_v<std::decay_t<E>, E> es true,
• cuando la llamada es válida, su objeto resultado almacena un subobjeto de tipo std::decay_t<E> inicializado directamente sin usar inicialización de lista con std::forward<E>(e), para cada argumento e en args... (en otras palabras, los objetos adaptadores de rango vinculan los argumentos por valor), y
• el objeto resultado es un objeto cierre adaptador de rango.

Al igual que otros objetos punto de personalización, sea

• a un objeto de la versión no calificada-cv del tipo de cualquier objeto adaptador de rango,
• args... cualquier grupo de argumentos que satisfaga las restricciones del operador operator() del tipo de a,

las llamadas a

• a(args...),
• std::as_const(a)(args...),
• std::move(a)(args...), y
• std::move(std::as_const(a))(args...)

son todas equivalentes.

El objeto resultado de cada una de estas expresiones es o bien un objeto vista (view) o un objeto cierre adaptador de rango.

Notas: el operador operator() no se admite para la versión calificada volatile o para la versión calificada const volatile de los tipos adaptadores de rango. Los arrays y funciones se convierten a punteros al vincularse.

Objetos cierre adaptadores de rango

Los objetos cierre adaptadores de rango son objetos cuyo tipo es el mismo que el de uno de los siguientes objetos (ignorando la calificación-cv):

• objetos adaptadores de rango unarios,
• los resultados de vincular los argumentos al final a objetos adaptadores de rango, y
• los resultados de encadenar dos objetos cierre adaptadores de rango al operador tubería operator|.

Los objetos cierre adaptadores de rango toman un rango visible (viewable_range) como su único argumento y devuelven una vista (view). Son invocables mediante el operador tubería : si C es un objeto cierre adaptador de rango y R es un rango visible (viewable_range), estas dos expresiones son equivalentes (ambas están bien formadas o mal formadas):

C(R)
R | C

Esta llamada reenvía los argumentos vinculados (si los hay) al objeto adaptador de rango asociado. Los argumentos vinculados (si los hay) se tratan idénticamente como l-valores o r-valores y calificados-cv a C.

Dos objetos cierre adaptadores de rango se pueden encadenar por el operador operator| para producir otro objeto cierre adaptador de rango: si C y D son objetos cierre adaptadores de rango, entonces C | D también es un objeto cierre adaptador de rango si esto es válido.

Los argumentos vinculados de C | D se determinan de la siguiente manera:

• existe un subobjeto en el objeto resultado del mismo tipo (descartada la calificación-cv) para cada subobjeto en ambos operandos que es un argumento vinculado,
• tal argumento vinculado es inicializado directamente no usando la inicialización de lista con el subobjeto fuente en el operando que lo contiene, donde la fuente se trata idénticamente como un l-valor o r-valor y calificado-cv al operando,
• el resultado es válido si y solo si la inicialización de todos los argumentos vinculados es válida.

El efecto y la validez del operador operator() se determina de la siguiente manera: dado un rango visible (viewable_range) R, estas dos expresiones son equivalentes (ambas están bien formadas o mal formadas):

R | C | D // (R | C) | D
R | (C | D)

Notas: el operador operator() no se admite para la versión calificada volatile o para la versión calificada const volatile de los tipos cierre adaptadores de rango.

Conceptos auxiliares

Los siguientes conceptos de solo exposición se usan para varios tipos, pero no son parte de la interfaz de la biblioteca estándar.

template<class R>   concept __SimpleView =                         // solo exposición     ranges::view<R> && ranges::range<const R> &&     std::same_as<std::ranges::iterator_t<R>, std::ranges::iterator_t<const R>> &&     std::same_as<std::ranges::sentinel_t<R>, std::ranges::sentinel_t<const R>>;

Notas

Macro de Feature-test
__cpp_lib_ranges

Ejemplo

Filtra los números pares y los eleva al cuadrado.

Ejecuta este código

#include <ranges>
#include <iostream>
 
int main()
{
    auto const enteros = {0, 1, 2, 3, 4, 5};
    auto par = [](int i) { return 0 == i % 2; };
    auto cuadrado = [](int i) { return i * i; };
 
    // sintaxis de "tubería" para componer las vistas:
    for (int i : enteros | std::views::filter(par) | std::views::transform(cuadrado)) {
        std::cout << i << ' ';
    }
 
    std::cout << '\n';
 
    // una sintaxis de composición "funcional" tradicional:
    for (int i : std::views::transform(std::views::filter(enteros, par), cuadrado)) {
        std::cout << i << ' ';
    }
}

Salida:

0 4 16
0 4 16

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 3509	C++20	No estaba claro cómo los objetos adaptadores de rango se vinculaban a los argumentos al final.	Se vinculan por valor.