C++ stellt miteinander kombinierbare Klassen zur Erzeugung (pseudo)zufälliger Zahlen (Generatoren), Saatwerte und Verteilungen bereit, deren Möglichkeiten weit über die der C-Funktion rand() aus <cstdlib> hinausgehen.

#include <ctime>
#include <functional>
#include <iostream>
#include <random>
 
void zufall()
{
#if defined(__MINGW32__) || defined(__MINGW64__)
  std::mt19937 engine(std::time(nullptr)); // siehe Anmerkung unten
#else  
  std::random_device rd;
  std::mt19937 engine(rd());
#endif  
  std::normal_distribution<> normal;
  std::function<double()> random = std::bind(normal, engine);
 
  for (int i = 0; i < 20; ++i)
  {
    std::cout << random() << ' ';
  }
}

Anmerkung: std::random_device ist bei älteren MinGW-Compilern unter Windows noch nicht zufällig; der Fehler wurde in g++ 9.2 behoben.¹⁾

Die Initialisierung mit der Systemzeit std::time(nullptr) oder "moderner", aber barocker mit std::chrono::system_clock::now().time_since_epoch().count() ist ein Hack für unkritische Anwendungen. Für kryptographisch sichere Saatwerte müsste auf Mittel des Betriebssystems zurückgegriffen werden.

Zufallsgeneratoren sind Funktionsobjekte, die beim Aufruf g() einen Ganzzahlwert aus dem geschlossenen Intervall [g.min(), g.max()] liefern. Ein Funktionsobjekt g heißt Engine, wenn es im Konstruktor eine Saatfolge übernehmen kann, die auch über g.seed(seq) wiederherstellbar ist. Mit g.discard(n) wird eine Anzahl von Zufallswerten übersprungen. Der Zustand einer Engine lässt sich in einen Strom schreiben bzw. aus einem Strom wiederherstellen. Mit Vergleichsoperatoren kann die Gleichheit der Zustände geprüft werden.

std::mt19937 engine1, engine2;
std::stringstream state;
state << engine1;
state >> engine2;
assert(engine1 == engine2);

Vorgefertigte (pseudozufällige) Generator-Engines (Tabelle) sind Spezialisierungen von Schablonen, die bekannten Algorithmen folgen:

• Ein linearer Kongruenzgenerator (LCG) erzeugt Wertfolgen $ x_{n+1}=(a x_n + c) \mod m $,
• ein subtraktiver Generator mit einer Vorschrift $ x_{n+1}=(x_{n-s} - x_{n-r} - c) \mod m $ (verallgemeinerter verzögerter Fibonacci-Generator).
• Mersenne-Twister bieten sehr lange Perioden ohne Wiederholungen.
• Eine discard_block_engine<Engine, p, r> überspringt nach r Werten die restlichen Werte einer von der Basis-Engine erzeugten Folge aus n Werten.
• Eine independent_bits_engine<Engine, w, Zieltyp> kombiniert w Bits der Basis-Engine zum Zieltyp.
• Die shuffle_order_engine<Engine, k> liefert jeweils k Werte der Basis-Engine in veränderter Reihenfolge.

Die Qualität eines Generators hängt stark von den gewählten Konstanten ab. Im Namensraum std sind folgende Generatoren (Engines) definiert:

Saatwert-Folgen std::seed_seq s(first,last) initialisieren Engines, s.generate(first,last) befüllt den angebenen Bereich [first,last), s.param(out) schreibt s.size() Werte in den Ausgabe-Iterator out.

std::seed_seq seed = {std::time(nullptr)};
std::vector<unsigned int> v(10);
seed.generate(begin(v), end(v));
for (auto e : v) std::cout << e << ' ';	

Verteilungen D(parameter) erzeugen mit dem Ganzzahl-Generator g beim Aufruf d(g) bzw. d(g, d.param()) eine Zufallszahl nach dem zugehörigen Verteilungsgesetz im Intervall [d.min(), d.max()]. Die Parameter p der Verteilung lassen sich auslesen und mit d.param(p) setzen sowie mit I/O-Operatoren in Ströme schreiben bzw. daraus lesen. Nach d.reset() hängen nachfolgende Werte nicht mehr von bisher erzeugten ab.

im Namensraum std definierte Klassen: