Namespaces
Variants

std::ranges:: generate_random

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
Definido en el encabezado <random>
Firma de llamada
template < class R, class G >

requiere ranges:: output_range < R, std:: invoke_result_t < G & >> &&
std:: uniform_random_bit_generator < std:: remove_cvref_t < G >>
constexpr ranges:: borrowed_iterator_t < R >

generate_random ( R && r, G && g ) ;
(1) (desde C++26)
template < class G, std:: output_iterator < std:: invoke_result_t < G & >> O,

std:: sentinel_for < O > S >
requires std:: uniform_random_bit_generator < std:: remove_cvref_t < G >>
constexpr O

generate_random ( O first, S last, G && g ) ;
(2) (desde C++26)
template < class R, class G, class D >

requires ranges:: output_range < R, std:: invoke_result_t < D & , G & >> &&
std:: invocable < D & , G & > &&
std:: uniform_random_bit_generator < std:: remove_cvref_t < G >> &&
std:: is_arithmetic_v < std:: invoke_result_t < D & , G & >>
constexpr ranges:: borrowed_iterator_t < R >

generate_random ( R && r, G && g, D && d ) ;
(3) (desde C++26)
template < class G, class D, std:: output_iterator < std:: invoke_result_t < D & , G & >> O,

std:: sentinel_for < O > S >
requires std:: invocable < D & , G & > &&
std:: uniform_random_bit_generator < std:: remove_cvref_t < G >> &&
std:: is_arithmetic_v < std:: invoke_result_t < D & , G & >>
constexpr O

generate_random ( O first, S last, G && g, D && d ) ;
(4) (desde C++26)

Intenta generar números aleatorios con la generate_random función miembro del generador de números aleatorios o la distribución, lo que se espera que sea más eficiente. Recurre a la generación elemento por elemento si no hay disponible ninguna generate_random función miembro.

Sea la operación de respaldo llamar a ranges:: generate ( std:: forward < R > ( r ) , std:: ref ( g ) ) o ranges:: generate ( std:: forward < R > ( r ) , [ & d, & g ] { return std:: invoke ( d, g ) ; } ) para (1) o (3) respectivamente.

1) Llama a g. generate_random ( std:: forward < R > ( r ) ) si esta expresión está bien formada.
De lo contrario, sea I el tipo std:: invoke_result_t < G & > . Si R modela sized_range , llena r con ranges:: size ( r ) valores de tipo I realizando un número no especificado de invocaciones de la forma g ( ) o g. generate_random ( s ) , si dicha expresión está bien formada para un valor N y un objeto s de tipo std:: span < I, N > .
De lo contrario, realiza la operación de respaldo.
3) Llama a d. generate_random ( std:: forward < R > ( r ) , g ) si esta expresión está bien formada.
De lo contrario, sea I el tipo std:: invoke_result_t < D & , G & > . Si R modela sized_range , llena r con ranges:: size ( r ) valores de tipo I realizando un número no especificado de invocaciones de la forma std:: invoke ( d, g ) o d. generate_random ( s, g ) , si dicha expresión está bien formada para un valor N y un objeto s de tipo std:: span < I, N > .
De lo contrario, realiza la operación de respaldo.
2,4) Equivalente a (1,3) respectivamente, donde r se obtiene de ranges:: subrange < O, S > ( std :: move ( first ) , last ) .

Si los efectos de (1) o (3) no son equivalentes a los de la operación de respaldo correspondiente, el comportamiento no está definido.

El valor de N puede variar entre invocaciones. Las implementaciones pueden seleccionar valores más pequeños para rangos más cortos.

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

Contenidos

Parámetros

first, last - el par iterador-centinela que define el rango de elementos al que se escriben números aleatorios
r - el range al que se escriben números aleatorios
g - generador uniforme de bits aleatorios
d - objeto de distribución de números aleatorios

Notas

En el momento de la estandarización de std::ranges::generate_random , no existe ningún generador de números aleatorios o distribución en la biblioteca estándar que proporcione una función miembro generate_random .

std::ranges::generate_random puede ser más eficiente cuando se utiliza con un generador de números aleatorios definido por el usuario que encapsula una API vectorizada subyacente.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_ranges_generate_random 202403L (C++26) std::ranges::generate_random

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <random>
int main()
{
    std::default_random_engine eng;
    std::default_random_engine::result_type rs[16]{};
    std::ranges::generate_random(rs, eng);
    std::cout << std::left;
    for (int i{}; auto n : rs)
        std::cout << std::setw(11) << n << (++i % 4 ? ' ' : '\n');
}

Salida posible: 

16807       282475249   1622650073  984943658 
1144108930  470211272   101027544   1457850878
1458777923  2007237709  823564440   1115438165
1784484492  74243042    114807987   1137522503

Véase también

(C++20)
guarda el resultado de una función en un rango
(objeto función de algoritmo)
(C++20)
especifica que un tipo califica como generador uniforme de bits aleatorios
(concepto)