std::ranges::generate
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| Signatura de la llamada |
||
template< std::input_or_output_iterator O, std::sentinel_for<O> S, std::copy_constructible F > requires std::invocable<F&> && std::indirectly_writable<O, std::invoke_result_t<F&>> constexpr O generate( O first, S last, F gen ); |
(1) | (desde C++20) |
template< class R, std::copy_constructible F > requires std::invocable<F&> && ranges::output_range<R, std::invoke_result_t<F&>> constexpr ranges::borrowed_iterator_t<R> generate( R&& r, F gen ); |
(2) | (desde C++20) |
1) Asigna el resultado de invocaciones sucesivas del objeto función
gen a cada elemento del rango [first, last).2) Igual que (1), pero
r como el rango, como si usara ranges::begin(r) como first y ranges::end(r) como last.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, last | - | El rango de los elementos a modificar. |
| r | - | El rango de los elementos a modificar. |
| gen | - | El objeto función generador. |
Valor de retorno
Un iterador de salida que se compara igual que last.
Complejidad
Exactamente ranges::distance(first, last) invocaciones de gen() y asignaciones.
Posible implementación
struct generate_fn
{
template<std::input_or_output_iterator O, std::sentinel_for<O> S,
std::copy_constructible F>
requires std::invocable<F&> && std::indirectly_writable<O, std::invoke_result_t<F&>>
constexpr O operator()(O first, S last, F gen) const
{
for (; first != last; *first = std::invoke(gen), ++first)
{}
return first;
}
template<class R, std::copy_constructible F>
requires std::invocable<F&> && ranges::output_range<R, std::invoke_result_t<F&>>
constexpr ranges::borrowed_iterator_t<R> operator()(R&& r, F gen) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(gen));
}
};
inline constexpr generate_fn generate {};
|
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 device;
static std::mt19937 engine {device()};
return distr(engine);
}
void iota(auto& v, int n)
{
std::ranges::generate(v, [&n]() mutable { return n++; });
}
void print(std::string_view comment, const auto& v)
{
for (std::cout << comment; int i : v)
std::cout << i << ' ';
std::cout << '\n';
}
int main()
{
std::array<int, 8> v;
std::ranges::generate(v.begin(), v.end(), dado);
print("dado: ", v);
std::ranges::generate(v, dado);
print("dado: ", v);
iota(v, 1);
print("iota: ", v);
}
Posible salida:
dado: 4 3 1 6 6 4 5 5
dado: 4 2 5 3 6 2 6 2
iota: 1 2 3 4 5 6 7 8
Véase también
(C++20) |
Guarda el resultado de N aplicaciones de una función. (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 todos los elementos de un rango. (plantilla de función) |