Espacios de nombres
Variantes
Acciones

Biblioteca de rangos (C++20)

De cppreference.com
< cpp
 
 
 

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 archivo de encabezado <ranges>
Definido en el espacio de nombres std::ranges

Contenido

Acceso a rangos
Devuelve un iterador al principio de un rango
(objeto de punto de personalización) [editar]
(C++20)
Devuelve un iterador al final de un rango.
(objeto de punto de personalización) [editar]
Devuelve un iterador inverso a un rango.
(objeto de punto de personalización) [editar]
(C++20)
Devuelve un iterador final inverso a un rango.
(objeto de punto de personalización) [editar]
(C++20)
Obtiene el tamaño de un rango cuyo tamaño puede calcularse en tiempo constante.
(objeto de punto de personalización) [editar]
(C++20)
Comprueba si un rango está vacío.
(objeto de punto de personalización) [editar]
(C++20)
Obtiene un puntero al principio de un rango contiguo.
(objeto de punto de personalización) [editar]
Primitivas de rangos
Obtiene los tipos asociados de un rango.
(plantilla de alias) [editar]
Control de iteradores pendientes
Un tipo marcador de posición que indica que un iterador o un subrango (subrange) no debe devolverse ya que quedaría pendiente.
(clase) [editar]
Obtiene el tipo de iterador o tipo de subrango (subrange) de un rango prestado (borrowed_range).
(plantilla de alias) [editar]
Conceptos de rangos
Especifica que un tipo es un rango. Es decir, proporciona un iterador begin y un centinela end.
(concepto) [editar]
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) [editar]
Especifica que un rango conoce su tamaño en tiempo constante.
(concepto) [editar]
Especifica que un rango es una vista. Es decir, realiza copia, movimiento y asignación en tiempo constante.
(concepto) [editar]
Especifica un rango cuyo tipo de iterador satisface a input_iterator.
(concepto) [editar]
Especifica un rango cuyo tipo de iterador satisface a output_iterator.
(concepto) [editar]
Especifica un rango cuyo tipo de iterador satisface a forward_iterator.
(concepto) [editar]
Especifica un rango cuyo tipo de iterador satisface a bidirectional_iterator.
(concepto) [editar]
Especifica un rango cuyo tipo de iterador satisface a random_access_iterator.
(concepto) [editar]
Especifica un rango cuyo tipo de iterador satisface a contiguous_iterator.
(concepto) [editar]
Especifica que un rango tiene tipos de iterador y centinela idénticos.
(concepto) [editar]
Especifica los requerimientos para un rango (range) para que sea convertible de forma segura a una vista (view).
(concepto) [editar]
Vistas
Plantilla de clase asistente para definir vistas (view), usando el patrón de plantilla curiosamente recurrente (CRTP).
(plantilla de clase) [editar]
Combina un par iterador-centinela en una vista (view).
(plantilla de clase) [editar]

[editar] Fábricas de rangos

Definido en el archivo de encabezado <ranges>
Definido en el espacio de nombres std::ranges
Una vista (view) sin elementos.
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) que contiene un solo elemento de un valor específico.
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) que consiste en una secuencia generada al incrementar repetidamente un valor inicial.
(plantilla de clase) (objeto adaptador de rango) [editar]
Crea un subrange a partir de un iterador y una cuenta.
(objeto de punto de personalización) [editar]

[editar] Adaptadores de rangos

Los adaptadores de rangos aceptan un viewable_range como sus primeros argumentos y devuelven una vista (view).

Si un adaptador toma solo un argumento, también se puede llamar usando el operador OR inclusivo: si C es un objeto adaptador de rango y R es un viewable_range, estas dos expresiones son equivalentes:

C(R)
R | C

Los adaptadores de rango unarios también se pueden encadenar para producir otro adaptador de rango: si C y D son objetos de adaptador de rango y R es un viewable_range , entonces C | D también es un objeto adaptador de rango, y estas dos expresiones son equivalentes:

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

Si un adaptador toma múltiples argumentos, estas formas son equivalentes:

adaptor(range, args...)
adaptor(args...)(range)
range | adaptor(args...)

En este case, adaptor(args...) es un objeto de adaptador de rango unario.

Definido en el archivo de encabezado <ranges>
Definido en el espacio de nombres std::ranges
Una vista (view) que incluye todos los elementos de un rango (range).
(plantilla de alias) (objeto adaptador de rango) [editar]
Una vista (view) de los elementos de algún otro rango (range).
(plantilla de clase) [editar]
Una vista (view) que consiste en los elementos de un rango (range) que satisface un predicado.
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) de una secuencia que aplica un función de transformación a cada elemento.
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) que consiste de los primeros N elementos de otra vista.
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) que consiste en los elementos iniciales de otra vista, hasta el primer elemento sobre el cual un predicado devuelva falso.
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) que consiste en los elementos de otra vista, saltándose los primeros N elementos.
(plantilla de clase) (objeto adaptador de rango) [editar]
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) [editar]
Una vista (view) que consiste en la secuencia obtenida al aplanar una vista de rangos (range).
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) sobre los subrangos obtenidos al dividir otra vista usando un delimitador.
(plantilla de clase) (objeto adaptador de rango) [editar]
Convierte una vista (view) a un rango común (common_range).
(plantilla de clase) (objeto adaptador de rango) [editar]
Una vista (view) que itera sobre los elementos de otra vista bidirectional en orden inverso.
(plantilla de clase) (objeto adaptador de rango) [editar]
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) [editar]
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) [editar]
Toma una vista (view) que consiste valores similares a pares y produce una vista de los primeros elementos de cada par.
(plantilla de clase) (objeto adaptador de rango) [editar]
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) [editar]

Algunos adaptadores de rango envuelven su elemento u objeto función con el envolvente semiregular.

[editar] Conceptos asistentes

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

template<typename 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>>;
template<typename T, typename U>

  concept __NotSameAs =                          // solo exposición

    !std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;

[editar] Ejemplos

#include <vector>
#include <ranges>
#include <iostream>
 
int main()
{
    std::vector<int> ints{0,1,2,3,4,5};
    auto even = [](int i){ return 0 == i % 2; };
    auto square = [](int i) { return i * i; };
 
    for (int i : ints | std::views::filter(even) | std::views::transform(square)) {
        std::cout << i << ' ';
    }
}

Salida:

0 4 16