std::ranges::views::take, std::ranges::take_view

 

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

 

std::ranges::take_view

Funciones miembro

take_view::take_view (C++20)

take_view::base (C++20)

take_view::begin (C++20)

take_view::end (C++20)

take_view::size (C++20)

Guías de deducción

Centinela

take_view::sentinel::sentinel (C++20)

take_view::sentinel::base (C++20)

operator==(std::counted_iterator,take_view::sentinel) (C++20)

 

<tbody> </tbody>

Definido en el archivo de encabezado <ranges>
template< ranges::view V > class take_view : public ranges::view_interface<take_view<V>>	(1)	(desde C++20)
namespace views { inline constexpr /*no especificado*/ take = /*no especificado*/; }	(2)	(desde C++20)
Signatura de la llamada
template< ranges::viewable_range R, class DifferenceType > requires /* véase a continuación */ constexpr ranges::view auto take( R&& r, DifferenceType&& count );		(desde C++20)
template< class DifferenceType > constexpr /*cierre de adaptador de rango*/ take( DifferenceType&& count );		(desde C++20)

1) Un adaptador de rango que representa una vista (view) de los elementos de una secuencia subyacente, iniciando en el comienzo y terminando en un límite dado.

2) views::take es un objeto adaptador de rango. La expresión views::take(e, f) resulta en una vista que representa los primeros f elementos de e. El resultado no es necesariamente un objeto take_view.

See More

Es equivalente en expresión a (donde T es std::remove_cvref_t<decltype((e))> y D es ranges::range_difference_t<decltype((e))>):

• ((void)f, static_cast<T>(e)), si T es una vista ranges::empty_view, excepto que las evaluaciones de e y f están secuenciadas de manera indeterminada;
• U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), si T es una especialización de std::span, std::basic_string_view, o ranges::subrange que modela tanto random_access_range como sized_range, donde U es

• std::span<typename T::element_type>, si T es una especialización de std::span;
• T, si T es una especialización de std::basic_string_view;
• ranges::subrange<ranges::iterator_t<T>>, si T es una especialización de ranges::subrange;

• ranges::iota_view(*ranges::begin(e), *(ranges::begin(e) + std::min<D>(ranges::distance(e), f))), si T es una especialización de ranges::iota_view que modela tanto random_access_range como sized_range;
• de lo contrario, take_view(e, f).

En todos los casos, decltype((f)) debe modelar std::convertible_to<D>.

take_view modela los conceptos contiguous_range, random_access_range, bidirectional_range, forward_range, input_range, y sized_range cuando la vista subyacente V modela los conceptos respectivos. Modela common_range cuando la vista subyacente V modela tanto random_access_range como sized_range.

Equivalente en expresión

La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.

Funciones miembro

(constructor) (C++20)	Construye un objeto take_view (función miembro pública)
base (C++20)	Devuelve una copia de la vista (adaptada) subyacente. (función miembro pública)
begin (C++20)	Devuelve un iterador al comienzo. (función miembro pública)
end (C++20)	Devuelve un iterador o un centinela al final. (función miembro pública)
size (C++20)	Devuelve el número de elementos. Se proporciona solo si el rango (adaptado) subyacente satisface sized_range . (función miembro pública)
Heredadas de ranges::view_interface
empty (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
operator bool (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si ranges::empty le es aplicable. (función miembro pública de std::ranges::view_interface<D>)
data (C++20)	Obtiene la dirección de los datos de una vista derivada. Se proporciona si su tipo iterador satisface contiguous_iterator. (función miembro pública de std::ranges::view_interface<D>)
front (C++20)	Devuelve el primer elemento en la vista derivada. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
back (C++20)	Devuelve el último elemento en una vista derivada. Se proporciona si la vista derivada satisface bidirectional_range y common_range. (función miembro pública de std::ranges::view_interface<D>)
operator[] (C++20)	Devuelve el enésimo elemento en la vista derivada. Se proporciona si la vista derivada satisface random_access_range. (función miembro pública de std::ranges::view_interface<D>)

Clases anidadas

sentinel (C++20)

El tipo centinela. (plantilla de clase miembro de solo exposición)

Plantillas auxiliares

<tbody> </tbody>

template<class T> inline constexpr bool enable_borrowed_range<std::ranges::take_view<T>> = std::ranges::enable_borrowed_range<T>;		(desde C++20)

Esta especialización de std::ranges::enable_borrowed_range hace que take_view satisfaga borrowed_range cuando la vista subyacente lo satisface.

Ejemplo

Ejecuta este código

#include <algorithm>
#include <iostream>
#include <ranges>

auto imprimir = [](char x) { std::cout << x; };

int main()
{
    constexpr char pi[] { '3', '.', '1', '4', '1', '5', '9', '2' };

    std::ranges::for_each(pi | std::ranges::views::take(6), imprimir);
    std::cout << '\n';

    std::ranges::for_each(std::ranges::take_view{pi, 42}, imprimir); // toma solo 8 chars
    std::cout << '\n';                                               // de manera segura
}

Salida:

3.1415
3.141592

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 3494	C++20	take_view nunca era un borrowed_range	Es un borrowed_range si su vista subyacente lo es.
LWG 3407	C++20	views::take a veces fracasaba al construir un rango de acceso aleatorio con tamaño.	Se ajustó el tipo resultado para que la construcción siempre sea válida.

Véase también

views::counted (C++20)	Crea un subrango a partir de un iterador y una cuenta. (objeto punto de personalización)
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::copy_n (C++20)	Copia un número de elementos a una nueva ubicación. (niebloid)