std::ranges::iota, std::ranges::iota_result
De cppreference.com
<tbody>
</tbody>
| 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 > requires std::indirectly_writable<O, const T&> constexpr iota_result<O, T> iota( O first, S last, T value ); |
(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;
...
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.
|
Valor de retorno
{last, value + ranges::distance(first, last)}
Complejidad
Exactamente last - first incrementos y asignaciones.
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;
|
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
|
Ejemplo
El siguiente ejemplo aplica ranges::shuffle a un std::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
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) |