std::ranges::views::iota, std::ranges::iota_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::iota_view

Funciones miembro

iota_view::iota_view (C++20)

iota_view::begin (C++20)

iota_view::end (C++20)

iota_view::size (C++20)

Guías de deducción (C++20)

Conceptos auxiliares

decrementable (C++20)

avanzable (C++20)

Iterador

iota_view::iterator::iterator (C++20)

iota_view::iterator::operator* (C++20)

iota_view::iterator::operator[] (C++20)

iota_view::iterator::operator++ iota_view::iterator::operator++(int) (C++20)(C++20)

iota_view::iterator::operator-- iota_view::iterator::operator--(int) (C++20)(C++20)

iota_view::iterator::operator+= (C++20)

iota_view::iterator::operator-= (C++20)

operator==(iota_view::iterator) operator<(iota_view::iterator) operator>(iota_view::iterator) operator<=(iota_view::iterator) operator>=(iota_view::iterator) operator<=>(iota_view::iterator) (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

operator+(iota_view::iterator) (C++20)

operator-(iota_view::iterator) (C++20)

Centinela

iota_view::sentinel::sentinel (C++20)

operator==(iota_view::iterator,iota_view::sentinel) (C++20)

operator-(iota_view::iterator,iota_view::sentinel) (C++20)

 

<tbody> </tbody>

Definido en el archivo de encabezado <ranges>
template< std::weakly_incrementable W, std::semiregular Bound = std::unreachable_sentinel_t > requires __WeaklyEqualityComparableWith<W, Bound> && std::copyable<W> class iota_view : public ranges::view_interface<iota_view<W, Bound>>	(1)	(desde C++20)
namespace views { inline constexpr /*no especificado*/ iota = /*no especificado*/; }	(2)	(desde C++20)
Signatura de la llamada
template< class W > requires /* véase a continuación */ constexpr /* véase a continuación */ iota( W&& value );		(desde C++20)
template< class W, class Bound > requires /* véase a continuación */ constexpr /* véase a continuación */ iota( W&& value, Bound&& bound );		(desde C++20)

1) Una fábrica de rangos que genera una secuencia de elementos incrementando repetidamente un valor inicial. Puede ser con límites o sin límites (infinito).

2) views::iota(e) y views::iota(e, f) son equivalentes-en-expresión a (tienen el mismo efecto que) iota_view(e) y iota_view(e, f) respectivamente para cualquier subexpresión e y f adecuadas.

Equivalente en expresión

See More

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.

Objetos de punto de personalización

El nombre views::iota_view denota un objeto de punto de personalización, que es un objeto función const de un tipo clase literal semiregular (denotado, a efectos de exposición, como iota_view_ftor). Todos los ejemplares de iota_view_ftor son iguales. Por lo tanto, views::iota_view puede copiarse libremente y sus copias pueden usarse indistintamente.

Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requerimientos para los argumentos de views::iota_view mencionado anteriormente, iota_view_ftor satisfará a std::invocable<const iota_view_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de iota_view_ftor participa en la resolución de sobrecarga.

Datos miembro

La implementación típica de iota_view contiene dos datos miembros de datos no estáticos: el valor inicial value_ de tipo W y el valor centinela bound_ de tipo Bound. Los nombres que se muestran aquí son solo de exposición.

Funciones miembro

(constructor) (C++20)	Construye un objeto iota_view. (función miembro pública)
begin (C++20)	Obtiene el iterador al comienzo de una iota_view. (función miembro pública)
end (C++20)	Obtiene el centinela que denota el find de una iota_view. (función miembro pública)
size (C++20)	Obtiene el tamaño de una iota_view si tiene tamaño. (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>)
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>)

std::ranges::iota_view::iota_view

<tbody> </tbody>

iota_view() requires std::default_initializable<W> = default;	(1)	(desde C++20)
constexpr explicit iota_view( W value );	(2)	(desde C++20)
constexpr iota_view( std::type_identity_t<W> value, std::type_identity_t<Bound> bound );	(3)	(desde C++20)
constexpr iota_view( /*iterador*/ first, /* véase a continuación */ last );	(4)	(desde C++20)

1) Inicializa value_ y bound_ por valor mediante sus inicializadores de miembro por defecto (= W() y = Bound()).

2) Inicializa value_ con value e inicializa bound_ por valor. Este constructor se usa para crear iota_views sin límites, p. ej., iota(0) produce los números numbers 0,1,2..., infinitamente.

3) Inicializa value_ con value y bound_ con bound. El comportamiento no está definido si se modela std::totally_ordered_with<W, Bound> y bool(value <= bound) es false. Este constructor se usa para crear iota_views con límites, p. ej., iota(10, 20) produce números del 10 al 19.

4) Igual que (3), excepto que value_ se inicializa con el valor W almacenado en first, y

• si W y Bound son del mismo tipo, entonces el tipo de last es /*iterador*/ y bound_ se inicializa con el valor W almacenado en last,
• de lo contrario, si la vista iota_view no tiene límites (es decir, Bound es std::unreachable_sentinel_t), entonces el tipo de last es std::unreachable_sentinel_t y bound_ se inicializa con el valor std::unreachable_sentinel.
• de lo contrario, el tipo de last es /*centinela*/ y bound_ se inicializa con el valor Bound almacenado en last.

En cualquier caso, el tipo de last es el mismo que decltype(end()).

Para (2), (3), y (4), el comportamiento no está definido si la iota_view tiene límites (es decir, Bound no es std::unreachable_sentinel_t) y bound_ se inicializa a un valor inalcanzable desde value_.

Parámetros

value	-	El valor inicial.
bound	-	El límite.
first	-	El iterador que denota el valor inicial.
last	-	El iterador que denota o centinela que denota el límite.

std::ranges::iota_view::begin

<tbody> </tbody>

constexpr /*iterador*/ begin() const;		(desde C++20)

Devuelve un iterador inicializado con value_.

std::ranges::iota_view::end

<tbody> </tbody>

constexpr auto end() const;	(1)	(desde C++20)
constexpr /*iterador*/ end() const requires std::same_as<W, Bound>;	(2)	(desde C++20)

1) Devuelve un centinela de un tipo específico (mostrado aquí como /*centinela*/) inicializado con bound_ si está vista tiene límites, o std::unreachable_sentinel si esta vista no tiene límites.

2) Devuelve un iterador inicializado con bound_.

std::ranges::iota_view::size

<tbody> </tbody>

constexpr auto size() const requires (std::same_as<W, Bound> && /*avanzable*/<W>) || (/*es-similar-a-un-entero*/<W> && /*es-similar-a-un-entero*<Bound>) || std::sized_sentinel_for<Bound, W> { if constexpr (/*es-similar-a-un-entero*/<W> && /*es-similar-a-un-entero*/<Bound>) return (value_ < 0) ? ((bound_ < 0) ? /*a-similar-a-unsigned*/(-value_) - /*a-similar-a-unsigned*/(-bound_) : /*a-similar-a-unsigned*/(bound_) + /*a-similar-a-unsigned*/(-value_)) : /*a-similar-a-unsigned*/(bound_) - /*a-similar-a-unsigned*/(value_); else return /*a-similar-a-unsigned*/(bound_ - value_); }		(desde C++20)

Devuelve el tamaño de la vista si la vista tiene límites.

El concepto de solo exposición avanzable se describe en esta página.

La función de plantilla de solo exposición a-similar-a-unsigned convierte su argumento (que debe ser similar a un entero) a la versión correspondiente sin signo del tipo del argumento.

Guías de deducción

<tbody> </tbody>

template<class W, class Bound> requires (!/*es-similar-a-un-entero*/<W> || !/*es-similar-a-un-entero*/<Bound> || /*es-similar-a-un-entero-con-signo*/<W> == /*es-similar-a-un-entero-con-signo*/<Bound>) iota_view(W, Bound) -> iota_view<W, Bound>;		(desde C++20)

Para cualquier tipo T, /*es-similar-a-un-entero*/<T> es true si y solo si T es similar a un entero, y /*es-similar-a-un-entero-con-signo*/<T> es true si y solo si T es similar a un entero y capaz de representar valores negativos.

Ten en cuenta que la guía se protege contra errores de discrepancia con signo/sin signo, como views::iota(0, v.size()), donde 0 es un int con signo y v.size() es std::size_t (sin signo).

Clases anidadas

iterator (C++20)	El tipo iterador. (clase miembro de solo exposición)
sentinel (C++20)	El tipo centinela usado cuando la iota_view tiene límites, y Bound y W no son del mismo tipo. (clase miembro de solo exposición)

Plantillas auxiliares

<tbody> </tbody>

template<std::weakly_incrementable W, std::semiregular Bound> inline constexpr bool enable_borrowed_range<ranges::iota_view<W, Bound>> = true;		(desde C++20)

Esta especialización de std::ranges::enable_borrowed_range hace que iota_view satisfaga borrowed_range.

Ejemplo

Ejecuta este código

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

int main()
{
    for (int i : std::ranges::iota_view{1, 10})
        std::cout << i << ' ';
    std::cout << '\n';

    for (int i : std::views::iota(1, 10))
        std::cout << i << ' ';
    std::cout << '\n';

    for (int i : std::views::iota(1) | std::views::take(9))
        std::cout << i << ' ';
    std::cout << '\n';

    std::ranges::for_each(std::views::iota(1, 10), [](int i) {
        std::cout << i << ' ';
    });
    std::cout << '\n';
}

Salida:

1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9

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 3523	C++20	El par iterador-centinela podría usar el tipo centinela equivocado.	Se corrigió.
P2325R3	C++20	iota_view requería que W fuera semiregular ya que view requería default_initializable	Solo requiere que W sea copyable.
LWG 3610	C++20	size podría rechazar tipos de clase enteros.	Se hizo que se aceptara si es posible.

Véase también

iota (C++11)

Llena un rango con incrementos sucesivos del mismo valor de partida (plantilla de función)