Namespaces
Variants

Ranges library (since C++20)

From cppreference.net
C++
Ranges library
Range adaptors

La biblioteca de rangos es una extensión y generalización de las bibliotecas de algoritmos e iteradores que las hace más potentes al hacerlas componibles y menos propensas a errores.

La biblioteca crea y manipula vistas de rango, objetos ligeros que representan indirectamente secuencias iterables ( rangos ). Los rangos son una abstracción sobre

  • [ inicio , fin ) – pares de iteradores, por ejemplo rangos creados mediante conversión implícita desde contenedores. Todos los algoritmos que toman pares de iteradores ahora tienen sobrecargas que aceptan rangos (ej. ranges::sort )
  • inicio + [ ​ 0 ​ , tamaño ) – secuencias contadas, por ejemplo rango devuelto por views::counted
  • [ inicio , predicado ) – secuencias terminadas condicionalmente, por ejemplo rango devuelto por views::take_while
  • [ inicio , .. ) – secuencias no acotadas, por ejemplo rango devuelto por views::iota

La biblioteca de rangos incluye algoritmos de rango , que se aplican a rangos de forma inmediata, y adaptadores de rango , que se aplican a vistas de forma diferida. Los adaptadores pueden componerse en pipelines, de modo que sus acciones tienen lugar a medida que se itera la vista.

Definido en el encabezado <ranges>
namespace std {

namespace views = ranges :: views ;

}
(desde C++20)

El alias de espacio de nombres std::views se proporciona como una abreviatura para std::ranges::views .

Definido en el espacio de nombres std::ranges

Contenidos

Acceso a rangos
Definido en el encabezado <ranges>
Definido en el encabezado <iterator>
(C++20)
devuelve un iterador al inicio de un rango
(objeto de punto de personalización)
(C++20)
retorna un centinela que indica el final de un rango
(objeto de punto de personalización)
(C++20)
devuelve un iterador al inicio de un rango de solo lectura
(objeto de punto de personalización)
(C++20)
devuelve un centinela que indica el final de un rango de solo lectura
(objeto de punto de personalización)
(C++20)
devuelve un iterador inverso a un rango
(objeto de punto de personalización)
(C++20)
devuelve un iterador final inverso a un rango
(objeto de punto de personalización)
(C++20)
devuelve un iterador inverso a un rango de solo lectura
(objeto de punto de personalización)
(C++20)
devuelve un iterador inverso final a un rango de solo lectura
(objeto de punto de personalización)
(C++26)
devuelve un entero igual a la sugerencia de reserva proporcionada por un rango
(objeto de punto de personalización)
(C++20)
devuelve un entero igual al tamaño de un rango
(objeto de punto de personalización)
(C++20)
devuelve un entero con signo igual al tamaño de un rango
(objeto de punto de personalización)
(C++20)
comprueba si un rango está vacío
(objeto de punto de personalización)
(C++20)
obtiene un puntero al inicio de un rango contiguo
(objeto de punto de personalización)
(C++20)
obtiene un puntero al inicio de un rango contiguo de solo lectura
(objeto de punto de personalización)
Primitivas de rango
Definido en el encabezado <ranges>
(C++20) (C++23) (C++20) (C++23)
obtiene los tipos de iterador y centinela de un rango
(plantilla de alias)
(C++20) (C++20) (C++20)
obtiene los tipos de tamaño, diferencia y valor de un rango
(plantilla de alias)
(C++20) (C++23) (C++20) (C++20)
obtiene los tipos de referencia de un rango
(plantilla de alias)
Manejo de iteradores colgantes
Definido en el encabezado <ranges>
(C++20)
un tipo de marcador de posición que indica que un iterador o un subrange no debe ser devuelto ya que quedaría colgante
(clase)
(C++20)
obtiene el tipo de iterador o subrange de un borrowed_range
(plantilla de alias)
Otras utilidades
Definido en el encabezado <ranges>
(C++23)
etiqueta un rango para ser tratado como una secuencia en lugar de un valor único
(plantilla de clase)
Conceptos de rango
Definido en el encabezado <ranges>
(C++20)
especifica que un tipo es un rango, es decir, proporciona un begin iterador y un end centinela
(concepto)
(C++20)
especifica que un tipo es un range y los iteradores obtenidos de una expresión del mismo pueden ser devueltos de forma segura sin peligro de referencias colgantes
(concepto)
(C++26)
especifica que un rango puede estimar su tamaño en tiempo constante
(concept)
(C++20)
especifica que un rango conoce su tamaño en tiempo constante
(concepto)
(C++20)
especifica que un rango es una vista, es decir, tiene operaciones de copia/movimiento/asignación en tiempo constante
(concepto)
(C++20)
especifica un rango cuyo tipo de iterador satisface input_iterator
(concepto)
(C++20)
especifica un rango cuyo tipo de iterador satisface output_iterator
(concepto)
(C++20)
especifica un rango cuyo tipo de iterador satisface forward_iterator
(concepto)
(C++20)
especifica un rango cuyo tipo de iterador satisface bidirectional_iterator
(concepto)
(C++20)
especifica un rango cuyo tipo de iterador satisface random_access_iterator
(concepto)
(C++20)
especifica un rango cuyo tipo de iterador satisface contiguous_iterator
(concepto)
(C++20)
especifica que un rango tiene tipos de iterador y centinela idénticos
(concepto)
(C++20)
especifica los requisitos para que un range sea convertible de forma segura a una view
(concept)
(C++23)
especifica que un rango tiene elementos de solo lectura
(concepto)
Conversiones de rango
Definido en el encabezado <ranges>
(C++23)
construye un nuevo objeto no-vista a partir de un rango de entrada
(plantilla de función)
Vistas
Definido en el encabezado <ranges>
(C++20)
clase de plantilla auxiliar para definir una view , utilizando el patrón de plantilla curiosamente recurrente
(plantilla de clase)
(C++20)
combina un par iterador-sentinel en una view
(plantilla de clase)

Fábricas de rangos

Definido en el encabezado <ranges>
Definido en el espacio de nombres std::ranges
(C++20)
una view vacía sin elementos
(plantilla de clase) (plantilla de variable)
(C++20)
una view que contiene un único elemento de un valor especificado
(plantilla de clase) (objeto de punto de personalizació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 una secuencia generada produciendo repetidamente el mismo valor
(plantilla de clase) (objeto de punto de personalización)
(C++20)
una view que consiste en los elementos obtenidos mediante la aplicación sucesiva de operator>> en el flujo de entrada asociado
(plantilla de clase) (objeto de punto de personalización)

Adaptadores de rango

Definido en el encabezado <ranges>
Definido en el espacio de nombres std::ranges
(C++23)
clase plantilla base auxiliar para definir un objeto de cierre de adaptador de rango
(clase plantilla)
(C++20)
una view que incluye todos los elementos de un range
(alias de plantilla) (objeto adaptador de rango)
(C++20)
una view de los elementos de algún otro range
(plantilla de clase)
(C++20)
una view con propiedad exclusiva de algún range
(plantilla de clase)
(C++23)
una view de una secuencia que convierte cada elemento a un rvalue
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en los elementos de un range que satisface un predicado
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view de una secuencia que aplica una función de transformación a cada elemento
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en los primeros N elementos de otra view
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en los elementos iniciales de otra view , hasta el primer elemento en el cual un predicado devuelve false
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en elementos de otra view , omitiendo los primeros N elementos
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en los elementos de otra view , omitiendo la subsecuencia inicial de elementos hasta el primer elemento donde el predicado devuelve false
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que consiste en la secuencia obtenida al aplanar una view de range s
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que consiste en la secuencia obtenida al aplanar una vista de rangos, con el delimitador entre elementos
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view sobre los subrangos obtenidos al dividir otra view usando un delimitador
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view sobre los subrangos obtenidos al dividir otra view usando un delimitador
(plantilla de clase) (objeto adaptador de rango)
(C++26)
una view que consiste en la concatenación de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización)
(C++20)
crea un subrango a partir de un iterador y un contador
(objeto de punto de personalización)
(C++20)
convierte una view en un common_range
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view que itera sobre los elementos de otra vista bidireccional en orden inverso
(plantilla de clase) (objeto adaptador de rango)
(C++23)
convierte una view en un constant_range
(plantilla de clase) (objeto adaptador de rango)
(C++20)
toma una view que consiste en valores tuple-like y un número N, y produce una view del elemento N th de cada tupla
(plantilla de clase) (objeto adaptador de rango)
(C++20)
toma una view que consiste en valores tipo par y produce una view de los primeros elementos de cada par
(plantilla de clase) (objeto adaptador de rango)
(C++20)
toma una view que consiste en valores tipo par y produce una view de los segundos elementos de cada par
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que mapea cada elemento de la secuencia adaptada a una tupla que contiene tanto la posición del elemento como su valor
(plantilla de clase) (objeto adaptador de rango)
(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++23)
una view que consiste en los resultados de la aplicación de una función de transformación a los elementos correspondientes de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización)
(C++23)
una view que consiste en tuplas de referencias a elementos adyacentes de la vista adaptada
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que consiste en los resultados de aplicar una función de transformación a elementos adyacentes de la vista adaptada
(plantilla de clase) (objeto adaptador de rango)
(C++23)
un rango de view s que son fragmentos sucesivos no superpuestos de tamaño N de los elementos de otra view
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view cuyo M ésimo elemento es una view sobre los elementos M ésimo a (M + N - 1) ésimo de otra view
(plantilla de clase) (objeto adaptador de rango)
(C++23)
divide el view en subrangos entre cada par de elementos adyacentes para los cuales el predicado dado devuelve false
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que consiste en elementos de otra view , avanzando sobre N elementos a la vez
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que consiste en tuplas de resultados calculados por el producto cartesiano n-ario de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización)
(C++26)
una view que almacena en caché el último elemento accedido de su secuencia subyacente
(plantilla de clase) (objeto adaptador de rango)
(C++26)
convierte una view en un rango que es input_range -exclusivo y no es common_range
(plantilla de clase) (objeto adaptador de rango)

Generadores de rango (desde C++23)

Definido en el encabezado <generator>
Definido en el espacio de nombres std
(C++23)
Una view que representa un generador síncrono de corrutinas
(plantilla de clase)

Elementos auxiliares

Objetos adaptadores de rango

Consulte RangeAdaptorObject (RAO).

Objetos de cierre de adaptador de rango

Consulte RangeAdaptorClosureObject (RACO).

Objetos de punto de personalización

Ver Customization point object (CPO).

Contenedor asignable

Algunos adaptadores de rango envuelven sus elementos u objetos de función con el copyable-box (until C++23) movable-box (since C++23) . El envoltorio aumenta el objeto envuelto con asignabilidad cuando es necesario.

Caché no propagador

Algunos adaptadores de rango se especifican en términos de una plantilla de clase solo para exposición non-propagating-cache , que se comporta casi como std:: optional < T > (consulte la descripción para conocer las diferencias).

Tipo condicionalmente const

template < bool Const, class T >
using /*maybe-const*/ = std:: conditional_t < Const, const T, T > ;
( solo para exposición* )

La plantilla de alias /*maybe-const*/ es una forma abreviada utilizada para aplicar condicionalmente el calificador const al tipo T .

Plantillas auxiliares para tipos similares a enteros

template < /*is-integer-like*/ T >
using /*make-signed-like-t*/ < T > = /* ver descripción */ ;
(1) ( solo para exposición* )
template < /*is-integer-like*/ T >
using /*make-unsigned-like-t*/ < T > = /* ver descripción */ ;
(2) ( solo para exposición* )
template < /*is-integer-like*/ T >

/*make-unsigned-like-t*/ < T > /*to-unsigned-like*/ ( T t )
{
return static_cast < /*make-unsigned-like-t*/ < T >> ( t ) ;

}
(3) ( solo para exposición* )
1) Para un tipo similar a entero T :
  • Si T es un tipo entero, /*make-signed-like-t*/ < T > es std:: make_signed_t < T > .
  • En caso contrario, /*make-signed-like-t*/ < T > es un tipo correspondiente no especificado similar a entero con signo del mismo ancho que T .
2) Para un tipo similar a entero T :
  • Si T es un tipo entero, /*make-unsigned-like-t*/ < T > es std:: make_unsigned_t < T > .
  • De lo contrario, /*make-signed-like-t*/ < T > es un tipo no especificado correspondiente similar a entero sin signo del mismo ancho que T .
3) Convierte explícitamente t a /*make-unsigned-like-t*/ < T > .

Asistentes de objetos de punto de personalización

template < ranges:: input_range R >

constexpr auto & /*possibly-const-range*/ ( R & r ) noexcept
{
if constexpr ( ranges:: input_range < const R > )
return const_cast < const R & > ( r ) ;
else
return r ;

}
(1) ( solo para exposición* )
template < class T >

constexpr auto /*as-const-pointer*/ ( const T * p ) noexcept
{
return p ;

}
(2) ( solo para exposición* )

Algunos objetos de punto de personalización de acceso a rangos se especifican en términos de estas plantillas de función solo para exposición.

1) /*possibly-const-range*/ devuelve la versión calificada como const de r si const R modela input_range ; de lo contrario, devuelve r sin realizar ninguna conversión.
2) /*as-const-pointer*/ devuelve un puntero a objeto de tipo constante.

Ayudantes de adaptador de rango

template < class F, class Tuple >

constexpr auto /*tuple-transform*/ ( F && f, Tuple && tuple )
{
return std:: apply ( [ & ] < class ... Ts > ( Ts && ... args )
{
return std:: tuple < std:: invoke_result_t < F & , Ts > ... >
( std:: invoke ( f, std:: forward < Ts > ( args ) ) ... ) ;
} , std:: forward < Tuple > ( tuple ) ) ;

}
(1) ( solo para exposición* )
template < class F, class Tuple >

constexpr void /*tuple-for-each*/ ( F && f, Tuple && tuple )
{
std:: apply ( [ & ] < class ... Ts > ( Ts && ... args )
{
( static_cast < void > ( std:: invoke ( f, std:: forward < Ts > ( args ) ) ) , ... ) ;
} , std:: forward < Tuple > ( tuple ) ) ;

}
(2) ( solo para exposición* )
template < class T >

constexpr T & /*as-lvalue*/ ( T && t )
{
return static_cast < T & > ( t ) ;

}
(3) ( solo para exposición* )

Algunos adaptadores de rango se especifican en términos de estas plantillas de función solo para exposición.

1) /*tuple-transform*/ devuelve una nueva tupla construida aplicando f a cada elemento de tuple .
2) /*tuple-for-each*/ aplica f a cada elemento de tuple y no devuelve nada.
3) /*as-lvalue*/ reenvía rvalue t como lvalue.

Conceptos auxiliares

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

template < class R >

concepto /*simple-view*/ =
ranges:: view < R > && ranges:: range < const R > &&
std:: same_as < ranges:: iterator_t < R > , ranges:: iterator_t < const R >> &&

std:: same_as < ranges:: sentinel_t < R > , ranges:: sentinel_t < const R >> ;
(1) ( solo para exposición* )
template < class I >

concepto /*has-arrow*/ =
ranges :: input_iterator < I > &&

( std:: is_pointer_v < I > || requiere ( const I i ) { i. operator - > ( ) ; } ) ;
(2) ( solo para exposición* )
template < class T, class U >

concepto /*different-from*/ =

! std:: same_as < std:: remove_cvref_t < T > , std:: remove_cvref_t < U >> ;
(3) ( solo para exposición* )
template < class R >

concepto /*rango-con-referencias-movibles*/ =
ranges:: input_range < R > &&
std:: move_constructible < ranges:: range_reference_t < R >> &&

std:: move_constructible < ranges:: range_rvalue_reference_t < R >> ;
(4) ( solo para exposición* )
template < bool C, class ... Views >

concepto /*all-random-access*/ =
( ranges:: random_access_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(5) ( solo para exposición* )
template < bool C, class ... Views >

concepto /*all-bidirectional*/ =
( ranges:: bidirectional_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(6) ( solo para exposición* )
template < bool C, class ... Views >

concepto /*all-forward*/ =
( ranges:: forward_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(7) ( solo para exposición* )

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_generator 202207L (C++23) std:: generator – generador de corrutina síncrona para rangos
__cpp_lib_ranges 201911L (C++20) Biblioteca de rangos y algoritmos restringidos
202106L (C++23)
(DR20) 		Vistas no inicializables por defecto
202110L (C++23)
(DR20) 		Vistas con propiedad
202202L (C++23) ranges:: range_adaptor_closure
202207L (C++23) Flexibilización de los adaptadores de rango para permitir tipos de solo movimiento
202211L (C++23) Eliminación de sobrecargas "poison pills" (P2602) en ranges:: begin etc
202302L (C++23) Relajando los rangos para permitir ciertas proyecciones
202406L (C++26)
(DR20) 		Eliminar el requisito de referencia común de los conceptos invocables indirectamente
__cpp_lib_ranges_as_const 202207L (C++23) std:: const_iterator , ranges:: as_const_view
__cpp_lib_ranges_as_rvalue 202207L (C++23) ranges:: as_rvalue_view
__cpp_lib_ranges_cache_latest 202411L (C++26) ranges :: cache_latest_view
__cpp_lib_ranges_cartesian_product 202207L (C++23) ranges:: cartesian_product_view
__cpp_lib_ranges_chunk 202202L (C++23) ranges:: chunk_view
__cpp_lib_ranges_chunk_by 202202L (C++23) ranges:: chunk_by_view
__cpp_lib_ranges_concat 202403L (C++26) ranges:: concat_view
__cpp_lib_ranges_enumerate 202302L (C++23) ranges :: enumerate_view
__cpp_lib_ranges_join_with 202202L (C++23) ranges:: join_with_view
__cpp_lib_ranges_repeat 202207L (C++23) ranges:: repeat_view
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges :: reserve_hint y ranges :: approximately_sized_range
__cpp_lib_ranges_slide 202202L (C++23) ranges:: slide_view
__cpp_lib_ranges_stride 202207L (C++23) ranges:: stride_view
__cpp_lib_ranges_to_container 202202L (C++23) ranges:: to
__cpp_lib_ranges_to_input 202502L (C++26) ranges :: to_input_view
__cpp_lib_ranges_zip 202110L (C++23) ranges:: zip_view ,
ranges:: zip_transform_view ,
ranges:: adjacent_view ,
ranges:: adjacent_transform_view

Ejemplo

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

Salida: 

0 4 16
0 4 16

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 3509
( P2281R1 ) 		C++20 no estaba claro cómo los objetos adaptadores de rango enlazaban argumentos finales se enlazan
por valor
LWG 3948 C++23 possibly-const-range y as-const-pointer
no se declararon noexcept 		declarados noexcept
LWG 4027 C++23 possibly-const-range no añadiría calificación const
para rangos que ya modelaban constant_range 		añade calificación const
para dichos rangos
LWG 4112 C++20 has-arrow no requería que i estuviera calificado como const requiere

Véase también