Wie erzeuge ich eine Zufallszahl mit der C ++ 11 Standardbibliothek?

Den neuen C++11-Standard hat ein ganzes Kapitel gewidmet-Zufallszahlen-Generatoren. Aber wie führe ich die einfachste, am häufigsten die Aufgabe, die codiert werden, wie diese, aber ohne Rückgriff auf die standard-C-Bibliothek:

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

Gibt es sinnvolle Voreinstellungen für die random-Nummer, Motoren, Verteilungen, und die Samen, die man nutzen könnte aus der box?

InformationsquelleAutor der Frage Bartosz Milewski | 2011-08-27

c++c++11 random

30

Sollten Sie in der Lage sein, etwas zu tun:
```
std::default_random_engine e((unsigned int)time(0));
int i = e();
```
Die Qualität der default_random_engine ist von der Implementierung abhängig. Sie können auch std::min_rand0 oder std::min_rand.

Wahrscheinlich einen besseren Weg, um Samen eine zufällige Motor ist mit als wahre eine zufällige Zahl, da ist von der Umsetzung eher als time.

E. g.
```
std::random_device rd;
std::default_random_engine e( rd() );
```
InformationsquelleAutor der Antwort CB Bailey

Vereinheitlichung und Vereinfachung einige der Proben bereits vorausgesetzt, ich werde zusammenfassen:

//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{}()));

Dann lief ich einige tests, um zu sehen, was die Standardeinstellungen Aussehen:

#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);
}

Erzeugt die Ausgabe:

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

So, wie wir sehen können, mt19937 und default_random_engine verschiedene Standard-Palette, so uniform_int_distribution empfohlen.

Auch, Standard uniform_int_distribution [0, max_int] (nicht-negativen), auch wenn Sie eine vorzeichenbehaftete Ganzzahl-Typ. Müssen Angebot ausdrücklich wenn Sie wollen die volle Palette.

Schließlich seine wichtig zu erinnern, diese in Zeiten wie diesen.

InformationsquelleAutor der Antwort mmocny

2

Wenn der vorhandene code angebracht wurde, bevor der neue standard ist, dann wird es auch weiterhin sein. Die neue Zufallszahlen-Generatoren wurden Hinzugefügt, für Anwendungen, die eine höhere Qualität der pseudo-Zufälligkeit, z.B. stochastische simulation.

InformationsquelleAutor der Antwort David Heffernan

Ich verwende den folgenden code in meinem Projekt. 'engine' und 'Verteilung' kann eines der von der Bibliothek bereitgestellten.

#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';

InformationsquelleAutor der Antwort dimitri

Hier gehen Sie. Random doubles in einer Reihe:

//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;
}

InformationsquelleAutor der Antwort Carl

0

Random number generation ist ein schwieriges problem. Es gibt keine wirklich zufällige Art und Weise, es zu tun. Wenn Sie nur generieren Zufälligkeit Samen eine Spiel-Umgebung, dann ist dein Ansatz in Ordnung sein sollte. rand() hat mehrere Mängel.

Wenn Sie benötigen, Zufälligkeit zu generieren Verschlüsselungsschlüssel, dann sind Sie S. O. L. Der beste Weg in diesem Fall ist zu gehen, um das Betriebssystem, die in der Regel-Mechanismus. Auf POSIX, dass die random () - (oder Lesen aus /dev/random wenn Sie so entsorgt). Unter Windows können Sie mithilfe der CryptoAPI:

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

InformationsquelleAutor der Antwort Adam Hawes
0

Könnte man RC4 verwendet zum generieren von zufälligen bytes. Dies hat wohl die Eigenschaften, die Sie wollen. Es ist schnell und relativ einfach zu implementieren. Die Sequenz wiederholbar über alle Implementierungen, wenn der seed bekannt ist, und völlig unvorhersehbar ist, wenn der Samen ist nicht bekannt. http://en.wikipedia.org/wiki/RC4

InformationsquelleAutor der Antwort Matt Mahoney

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.