std::ranges::views::iota, std::ranges::iota_view, std::ranges::views::indices
De es.cppreference.net
| Definido en el encabezado <ranges>
|
||
template< std::weakly_incrementable W,
std::semiregular Bound = std::unreachable_sentinel_t >
requires /*weakly-equality-comparable-with*/<W, Bound> && std::copyable<W>
class iota_view
: public ranges::view_interface<iota_view<W, Bound>>
|
(1) | (desde C++20) |
namespace views {
inline constexpr /* unspecified */ iota = /* unspecified */;
}
|
(2) | (desde C++20) |
namespace views {
inline constexpr /* unspecified */ indices = /* unspecified */;
}
|
(3) | (desde C++26) |
| Firma de llamada |
||
template< class W >
requires /* see below */
constexpr /* see below */ iota( W&& value );
|
(desde C++20) | |
template< class W, class Bound >
requires /* see below */
constexpr /* see below */ iota( W&& value, Bound&& bound );
|
(desde C++20) | |
template< class T >
requires /*is-integer-like*/<T>
constexpr /* see below */ indices( T bound );
|
(desde C++26) | |
1) Una fábrica de rango que genera una secuencia de elementos incrementando repetidamente un valor inicial. Puede ser acotada o no acotada (infinita).
2)
views::iota(e) y views::iota(e, f) son equivalentes en expresión a iota_view<std::decay_t<decltype((e))>>(e) y iota_view(e, f) respectivamente para cualquier subexpresión adecuada e y f.3) Sea
T igual a std::remove_cvref_t<decltype((e))>. Entonces views::indices(e) es equivalente en expresión a views::iota(T(0), e) para cualquier subexpresión adecuada e si /*is-integer-like*/<T> es true.Objetos de punto de personalización
El nombre
views::iota
denota un
objeto de punto de personalización
, que es un
objeto función
constante de un tipo de clase
literal
semiregular
. Consulte
CustomizationPointObject
para más detalles.
Miembros de datos
| Miembro | Descripción |
W value_
|
el valor inicial (objeto miembro de solo exposición*) |
Bound bound_
|
el valor centinela, puede ser inalcanzable (objeto miembro de solo exposición*) |
Funciones miembro
crea un
iota_view
(función miembro pública) |
|
obtiene el iterador inicial de un
iota_view
(función miembro pública) |
|
obtiene el centinela que denota el final de un
iota_view
(función miembro pública) |
|
comprueba si el
iota_view
está vacío (es decir, si el iterador y el centinela son iguales)
(función miembro pública) |
|
|
(opcional)
|
obtiene el tamaño de un
iota_view
(solo se proporciona si está acotado)
(función miembro pública) |
Heredado de ranges::view_interface | |
(C++23) |
devuelve un iterador constante al inicio del rango (función miembro pública de std::ranges::view_interface<D>)
|
(C++23) |
devuelve un centinela para el iterador constante del rango (función miembro pública de std::ranges::view_interface<D>)
|
| devuelve si la vista derivada no está vacía, únicamente si ranges::empty es aplicable a ella (función miembro pública de std::ranges::view_interface<D>)
| |
| devuelve el primer elemento en la vista derivada, únicamente si satisface forward_range (función miembro pública de std::ranges::view_interface<D>)
| |
| devuelve el último elemento en la vista derivada, únicamente si satisface bidirectional_range y common_range (función miembro pública de std::ranges::view_interface<D>)
| |
devuelve el nésimo elemento en la vista derivada, únicamente si satisface random_access_range (función miembro pública de std::ranges::view_interface<D>)
| |
Guías de deducción
Clases anidadas
|
el tipo de iterador
( clase miembro solo para exposición* ) |
|
el tipo de centinela utilizado cuando el
iota_view
está acotado y
Bound
y
W
no son del mismo tipo
( clase miembro solo para exposición* ) |
Plantillas auxiliares
|
template
<
std::
weakly_incrementable
W,
std::
semiregular
Bound
>
constexpr bool ranges:: enable_borrowed_range < ranges :: iota_view < W, Bound >> = true ; |
(desde C++20) | |
Esta especialización de
ranges::
enable_borrowed_range
hace que
iota_view
satisfaga
borrowed_range
.
Posible implementación
Consulte también la implementación en libstdc++.
| vistas::índices (3) |
|---|
namespace views {
inline constexpr auto indices = []</*is-integer-like*/ I>(I n)
{
return views::iota(I{}, n);
};
}
|
Notas
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_ranges_indices |
202506L |
(C++26) | ranges::views::indices
|
Ejemplo
Ejecutar este código
#include <algorithm>
#include <iostream>
#include <ranges>
struct Bound
{
int bound;
bool operator==(int x) const { return x == bound; }
};
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, Bound{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';
#if __cpp_lib_ranges_indices
constexpr int v[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
// auto broken_indices = views::iota(0, std::ranges::size(v));
// does not compile due to types (int VS size_t) mismatch
auto good_indices = std::views::indices(std::ranges::size(v));
for (auto i : good_indices)
std::cout << v[i] << ' ';
std::cout << '\n';
#endif
}
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
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 que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 4096 | C++20 |
views::iota
podría copiar un
iota_view
tal cual
|
prohibido |
| P2325R3 | C++20 |
iota_view
requería que
W
fuera
semiregular
como
view
requería
default_initializable
|
solo requiere que
W
sea
copyable
|
Referencias
- Estándar C++26 (ISO/IEC 14882:2026):
- 25.6.4 Vista Iota [range.iota]
- Estándar C++23 (ISO/IEC 14882:2024):
- 26.6.4 Vista Iota [range.iota]
- Estándar C++20 (ISO/IEC 14882:2020):
- 24.6.4 Vista Iota [range.iota]
Véase también
(C++11) |
rellena un rango con incrementos sucesivos del valor inicial (plantilla de función & objeto función de algoritmo) |
(C++23) |
|
(C++23) |
rellena un rango con incrementos sucesivos del valor inicial (objeto función de algoritmo) |
| una vista que consiste en una secuencia generada produciendo repetidamente el mismo valor (plantilla de clase) (objeto punto de personalización) | |
| una vista que asigna cada elemento de la secuencia adaptada a una tupla con la posición del elemento y su valor (plantilla de clase) (objeto adaptador de rango) |