std::ranges::generate_n
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| Signatura de la llamada |
||
template< std::input_or_output_iterator O, std::copy_constructible F > requires std::invocable<F&> && std::indirectly_writable<O, std::invoke_result_t<F&>> constexpr O generate_n( O first, std::iter_difference_t<O> n, F gen ); |
(desde C++20) | |
Asigna el resultado de invocaciones sucesivas del objeto función gen a cada elemento del rango [first, first + n), si 0 < n. De lo contrario no hace nada.
Las entidades similares a funciones descritas en esta página son niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Parámetros
| first | - | El comienzo del rango de los elementos a modificar. |
| n | - | El número de elementos a modificar. |
| gen | - | El objeto función generador. |
Valor de retorno
Un iterador más allá del último elemento asignado si 0 < count, first de lo contrario.
Complejidad
Exactamente n invocaciones de gen() y asignaciones.
Posible implementación
struct generate_n_fn
{
template<std::input_or_output_iterator O, std::copy_constructible F>
requires std::invocable<F&> && std::indirectly_writable<O, std::invoke_result_t<F&>>
constexpr O operator()(O first, std::iter_difference_t<O> n, F gen) const
{
for (; n-- > 0; *first = std::invoke(gen), ++first)
{}
return first;
}
};
inline constexpr generate_n_fn generate_n {};
|
Ejemplo
Ejecuta este código
#include <algorithm>
#include <array>
#include <iostream>
#include <random>
#include <string_view>
auto dado() // representa un dado
{
static std::uniform_int_distribution<int> distr {1, 6};
static std::random_device engine;
static std::mt19937 noise {engine()};
return distr(noise);
}
void print(const auto& v, std::string_view comment)
{
for (int i : v)
std::cout << i << ' ';
std::cout << '(' << comment << ")\n";
}
int main()
{
std::array<int, 8> v;
std::ranges::generate_n(v.begin(), v.size(), dado);
print(v, "dado");
std::ranges::generate_n(v.begin(), v.size(), [n {0}] mutable { return n++; });
// el mismo efecto que std::iota(v.begin(), v.end(), 0);
print(v, "iota");
}
Posible salida:
5 5 2 2 6 6 3 5 (dado)
0 1 2 3 4 5 6 7 (iota)
Véase también
(C++20) |
Guarda el resultado de una función en un rango. (niebloid) |
(C++20) |
Asigna un cierto valor a un rango de elementos. (niebloid) |
(C++20) |
Asigna un valor a un número de elementos. (niebloid) |
(C++20) |
Aplica una función a un rango de elementos. (niebloid) |
| Asigna el resultado de las llamadas sucesivas de una función a n elementos de un rango. (plantilla de función) |