std::ranges::view, std::ranges::enable_view, std::ranges::view_base

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

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

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

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

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

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	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

Definido en el archivo de encabezado <ranges>
template<class T> concept view =ranges::range<T>&&std::movable<T>&& ranges::enable_view<T>;	(1)	(desde C++20)
template<class T> inlineconstexprbool enable_view =     std::derived_from<T, view_base>||/*se-deriva-de-la-interfaz-de-vista*/<T>;	(2)	(desde C++20)
struct view_base {};	(3)	(desde C++20)

1) El concepto view (vista) especifica los requerimientos de un tipo range (rango) que tiene las propiedades semánticas adecuadas para su uso en la construcción de segmentaciones (pipelines) adaptadoras de rangos.

2) La plantilla de variable enable_view se usa para indicar si un rango (range) es una vista (view). /*se-deriva-de-la-interfaz-de-vista*/<T> es true si y solo si T tiene exactamente una clase base pública ranges::view_interface<U> para algún tipo U, y T no tiene clases base de tipo ranges::view_interface<V> para ningún otro tipo V.
Los usuarios pueden especializar enable_view a true para tipos definidos por el programa, no calificados-cv, que modelen view, y false para tipos que no. Tales especializaciones deben ser usables en expresiones constantes y tener tipo constbool.

3) Derivar de view_base habilita que los tipos range modelen view.

Requerimientos semánticos

1)T modela view solo si:

• la construcción por movimiento de T tiene complejidad de tiempo constante, y
• si \(\scriptsize N\)N copias o movimientos se hacen desde un objeto T que mantiene \(\scriptsize M\)M elementos, entonces estos \(\scriptsize N\)N objetos tienen una destrucción \(\scriptsize \mathcal{O}{(N+M)}\)𝓞(N+M) (lo que implica que un objeto view fuente de una operación de movimiento tiene una destrucción \(\scriptsize \mathcal{O}{(1)}\)𝓞(1) ), y
• o bien std::copy_constructible<T> es false, o la construcción por copia de T tiene complejidad de tiempo constante, y
• o bien std::copyable<T> es false, o la asignación por copia de T no tiene una complejidad de tiempo mayor que la de la destrucción seguida por construccón por copia.

Notas

Son ejemplos de tipos view:

• Un tipo range que envuelve un par de iteradores, por ejemplo, std::ranges::subrange<I>.
• Un tipo range que mantiene sus elementos por std::shared_ptr y comparte la propiedad con todas sus copias.
• Un tipo range que genera sus elementos bajo pedido, por ejemplo, std::ranges::iota_view.

Un contenedor copiable como std::vector<std::string> generalmente no cumple con los requerimientos semánticos de view, ya que copiar el contenedor copia todos sus elementos, lo que no puede hacerse en tiempo constante.

Mientras que las vistas se describieron originalmente como descrito como rangos de baratos de copiar y de no propiedad, no se requiere que un tipo sea copiable o de no propiedad para modelar view. Sin embargo, todavía debe ser barato de copiar (si es copiable), mover, asignar y destruir, para que los adaptadores de rangos no tengan una complejidad inesperada.

Por defecto, un tipo que modela movable y range se considera una vista si se deriva pública e inequivocadamente de view_base, o exactamente una especialización de std::ranges::view_interface.

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
P2325R3	C++20	view requería default_initializable	No se requiere.
LWG 3549	C++20	enable_view no detectaba herencia de view_interface	La detecta.
P2415R2	C++20	La restricción de la complejidad de tiempo de la destrucción era demasiado estricta.	Se relajó.