std::ranges::iota, std::ranges::iota_result
De cppreference.com
| Definido en el archivo de encabezado <numeric>
|
||
| Signatura de la llamada |
||
| template< std::input_or_output_iterator O, std::sentinel_for<O> S, std::weakly_incrementable T > |
(1) | (desde C++23) |
| template< std::weakly_incrementable T, ranges::output_range<const T&> R > constexpr iota_result<ranges::borrowed_iterator_t<R>, T> iota( R&& r, T value ); |
(2) | (desde C++23) |
| Tipos auxiliares |
||
| template< class O, class T > using iota_result = ranges::out_value_result<O, T>; |
(3) | (desde C++23) |
Llena el rango [first, last) con valores secuencialmente crecientes, comenzando con value y evaluando repetitivamente ++value.
Operación equivalente:
*(first) = value; *(first+1) = ++value; *(first+2) = ++value; *(first+3) = ++value; ...
Contenido |
[editar] Parámetros
| first, last | - | El rango de elementos a llenar con valores secuencialmente crecientes comenzando con value.
|
| value | - | Valor inicial a almacenar; la expresión ++value debe estar bien formada. |
[editar] Valor de retorno
{last, value + ranges::distance(first, last)}
[editar] Complejidad
Exactamente last - first incrementos y asignaciones.
[editar] Posible implementación
struct iota_fn { template< std::input_or_output_iterator O, std::sentinel_for<O> S, std::weakly_incrementable T > requires std::indirectly_writable<O, const T&> constexpr iota_result<O, T> operator()(O first, S last, T value) const { while (first != last) { *first = as_const(value); ++first; ++value; } return {std::move(first), std::move(value)}; } template< std::weakly_incrementable T, std::ranges::output_range<const T&> R > constexpr iota_result<std::ranges::borrowed_iterator_t<R>, T> operator()(R&& r, T value) const { return (*this)(std::ranges::begin(r), std::ranges::end(r), std::move(value)); } }; inline constexpr iota_fn iota; |
[editar] Notas
La función lleva el nombre de la función entera ⍳ del lenguaje de programación APL.
| Macro de Prueba de característica |
|---|
__cpp_lib_ranges_iota
|
[editar] Ejemplo
El siguiente ejemplo aplica ranges::shuffle a un vector de iteradores de std::list, ya que ranges::shuffle no se puede aplicar directamente a std::list. ranges::iota se usa para llenar ambos contenedores.
Ejecuta este código
#include <algorithm> #include <iostream> #include <list> #include <numeric> #include <random> #include <vector> int main() { std::list<int> l(10); std::ranges::iota(l.begin(), l.end(), -4); std::vector<std::list<int>::iterator> v(l.size()); std::ranges::iota(v, l.begin()); std::ranges::shuffle(v, std::mt19937{std::random_device{}()}); std::cout << "Contenido de la lista: "; for(auto n: l) std::cout << n << ' '; std::cout << '\n'; std::cout << "Contenido de la lista, barajada: "; for(auto i: v) std::cout << *i << ' '; std::cout << '\n'; }
Posible salida:
Contenido de la lista: -4 -3 -2 -1 0 1 2 3 4 5 Contenido de la lista, barajada: 0 -1 3 4 -4 1 -2 -3 2 5
[editar] Véase también
| Asigna por copia el valor dado a todos los elementos de un rango. (plantilla de función) | |
| (C++20) |
Asigna un cierto valor a un rango de elementos. (niebloid) |
| Asigna el resultado de las llamadas sucesivas de una función a todos los elementos de un rango. (plantilla de función) | |
| (C++20) |
Guarda el resultado de una función en un rango. (niebloid) |
| (C++20) |
Una vista (view) que consiste en una secuencia generada al incrementar repetidamente un valor inicial. (plantilla de clase) (objeto punto de personalización) |
| (C++11) |
Llena un rango con incrementos sucesivos del mismo valor de partida (plantilla de función) |
