¿Cómo puedo generar un número aleatorio utilizando la biblioteca estándar de C++ 11?

Question

El nuevo estándar C++ 11 tiene un capítulo completo dedicado a generadores de números aleatorios. Pero ¿Cómo se realiza el más simple de tareas, más común que se utiliza para ser codificada como este, pero sin recurrir a la biblioteca estándar de C:

srand((unsigned int)time(0)); 
int i = rand();

¿Hay valores por defecto razonables para los motores de números aleatorios, distribuciones, y semillas que uno podría usar fuera de la caja?

Answer 1

Usted debe ser capaz de hacer algo como:

std::default_random_engine e((unsigned int)time(0)); 
int i = e(); 

La calidad de la default_random_engine depende de la implementación. También puede usar std::min_rand0 o std::min_rand.

Probablemente una mejor manera de inicializar un motor aleatorio es con un número aleatorio tan verdadero como está disponible en la implementación en lugar de usar time.

E.g.

std::random_device rd; 
std::default_random_engine e(rd()); 

Answer 2

Si su código actual era apropiado antes del nuevo estándar, entonces seguirá siéndolo. Los nuevos generadores de números aleatorios se agregaron para aplicaciones que requieren una mayor calidad de pseudoaleatoriedad, p. simulación estocástica.

Answer 3

La generación aleatoria de números es un problema difícil. No hay una manera verdaderamente aleatoria de hacerlo. Si solo estás generando aleatoriedad para sembrar un entorno de juego, entonces tu enfoque debería estar bien. rand() tiene varias deficiencias.

Si necesita aleatoriedad para generar claves de cifrado, entonces es S.O.L. La mejor manera en ese caso es ir al sistema operativo, que generalmente tiene un mecanismo. En POSIX eso es aleatorio() (o lea desde/dev/random si está dispuesto). En Windows, puede utilizar el CryptoAPI:

https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers

Answer 4

Se puede usar RC4 para generar bytes aleatorios. Esto probablemente tiene las propiedades que desea. Es rápido y bastante simple de implementar. La secuencia es repetible en todas las implementaciones cuando se conoce la semilla, y es completamente impredecible cuando se desconoce la semilla. http://en.wikipedia.org/wiki/RC4

Answer 5

Uso el siguiente código en mi proyecto. 'motor' y 'distribución' pueden ser uno de los proporcionados por la biblioteca.

#include <random> 
#include <functional> 
#include <iostream> 
... 
std::uniform_int_distribution<unsigned int> unif; 
std::random_device rd; 
std::mt19937 engine(rd()); 
std::function<unsigned int()> rnd = std::bind(unif, engine); 

std::cout << rnd() << '\n'; 

Answer 6

unificar y simplificar algunas de las muestras ya previstas voy a resumir a:

// Good random seed, good engine 
auto rnd1 = std::mt19937(std::random_device{}()); 

// Good random seed, default engine 
auto rnd2 = std::default_random_engine(std::random_device{}()); 

// like rnd1, but force distribution to int32_t range 
auto rnd3 = std::bind(std::uniform_int_distribution<int32_t>{}, std::mt19937(std::random_device{}())); 

// like rnd3, but force distribution across negative numbers as well 
auto rnd4 = std::bind(std::uniform_int_distribution<int32_t>{std::numeric_limits<int32_t>::min(),std::numeric_limits<int32_t>::max()}, std::mt19937(std::random_device{}())); 

Entonces me encontré con algunas pruebas para ver cuáles son los valores por defecto se parecen:

#include <random> 
#include <functional> 
#include <limits> 
#include <iostream> 

template<class Func> 
void print_min_mean_max(Func f) { 
    typedef decltype(f()) ret_t; 
    ret_t min = std::numeric_limits<ret_t>::max(), max = std::numeric_limits<ret_t>::min(); 
    uint64_t total = 0, count = 10000000; 
    for (uint64_t i = 0; i < count; ++i) { 
     auto res = f(); 
     min = std::min(min,res); 
     max = std::max(max,res); 
     total += res; 
    } 
    std::cout << "min: " << min << " mean: " << (total/count) << " max: " << max << std::endl; 
} 

int main() { 
    auto rnd1 = std::mt19937(std::random_device{}()); 
    auto rnd2 = std::default_random_engine(std::random_device{}()); 

    auto rnd3 = std::bind(std::uniform_int_distribution<int32_t>{}, std::mt19937(std::random_device{}())); 
    auto rnd4 = std::bind(std::uniform_int_distribution<int32_t>{std::numeric_limits<int32_t>::min(),std::numeric_limits<int32_t>::max()}, std::mt19937(std::random_device{}())); 

    print_min_mean_max(rnd1); 
    print_min_mean_max(rnd2); 
    print_min_mean_max(rnd3); 
    print_min_mean_max(rnd4); 
} 

Produce la salida:

min: 234 mean: 2147328297 max: 4294966759 
min: 349 mean: 1073305503 max: 2147483423 
min: 601 mean: 1073779123 max: 2147483022 
min: -2147481965 mean: 178496 max: 2147482978 

Como podemos ver, mt19937 y default_random_engine tienen un rango predeterminado diferente, por lo que se recomienda usar uniform_int_distribution.

Además, el valor predeterminado uniform_int_distribution es [0, max_int] (no negativo), incluso cuando se utiliza un tipo de entero con signo. Debe proporcionar el rango explícitamente si desea un rango completo.

Finalmente, its important to remember this en momentos como estos.

Answer 7

Aquí tienes. Doble aleatorio en un rango:

// For ints 
// replace _real_ with _int_, 
// <double> with <int> and use integer constants 

#include <random> 
#include <iostream> 
#include <ctime> 
#include <algorithm> 
#include <iterator> 

int main() 
{ 
    std::default_random_engine rng(std::random_device{}()); 
    std::uniform_real_distribution<double> dist(-100, 100); //(min, max) 

    //get one 
    const double random_num = dist(rng); 

    //or.. 
    //print 10 of them, for fun. 
    std::generate_n( 
     std::ostream_iterator<double>(std::cout, "\n"), 
     10, 
     [&]{ return dist(rng);}); 
    return 0; 
}