C++ Academy · Lektion

Zufallszahlengeneratoren

Zufallsbits erzeugen

Zufallszahlengeneratoren ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum <random>?

Das alte rand() ist von geringer Qualität und schwer zu kontrollieren. Die Bibliothek <random> trennt die Zufälligkeit in Engines (Quellen für Zufallsbits) und Verteilungen (Form der Ausgabe).

#include <iostream>
#include <random>

int main() {
    std::mt19937 engine(42);
    std::cout << "engine produced a value\n";
    unsigned int v = engine();
    std::cout << (v != 0 ? "non-zero" : "zero") << '\n';
    return 0;
}

Der Mersenne-Twister

std::mt19937 ist die am häufigsten verwendete Engine: schnell, hochwertig und mit einer langen Periode. Die Zahl gibt ihre Zustandsgröße in Bits an.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(1);
    unsigned int a = gen();
    unsigned int b = gen();
    std::cout << (a != b ? "two different values" : "same") << '\n';
    return 0;
}

Engines sind deterministisch

Bei demselben Seed erzeugt eine Engine immer dieselbe Sequenz. Dadurch werden Ergebnisse reproduzierbar.

#include <iostream>
#include <random>

int main() {
    std::mt19937 a(123), b(123);
    std::cout << std::boolalpha << (a() == b()) << '\n';
    std::cout << (a() == b()) << '\n';
    return 0;
}

Die Engine aufrufen

Eine Engine ist aufrufbar. Jeder Aufruf von engine() gibt die nächste rohe Zufallszahl in ihrem Wertebereich zurück.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(7);
    for (int i = 0; i < 3; ++i) {
        unsigned int v = gen();
        std::cout << (v % 100) << ' ';
    }
    std::cout << '\n';
    return 0;
}

Der Wertebereich einer Engine

min() und max() geben den Bereich der Rohwerte an, die eine Engine ausgeben kann.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen;
    std::cout << "min: " << gen.min() << '\n';
    std::cout << "max: " << gen.max() << '\n';
    return 0;
}

Weitere Engines

Die Bibliothek bietet mehrere Engines:

minstd_rand: kleiner linearer Kongruenzgenerator.
mt19937: allgemeine Standard-Engine.
ranlux48: höhere Qualität, aber langsamer.

#include <iostream>
#include <random>

int main() {
    std::minstd_rand lcg(5);
    std::mt19937 mt(5);
    std::cout << (lcg() % 10) << ' ' << (mt() % 10) << '\n';
    return 0;
}

64-Bit-Engine

Verwenden Sie std::mt19937_64, wenn Sie 64-Bit-Zufallswerte benötigen, beispielsweise für große Hashes oder sehr große Wertebereiche.

#include <iostream>
#include <random>

int main() {
    std::mt19937_64 gen(99);
    unsigned long long v = gen();
    std::cout << "got a 64-bit value: " << (v != 0 ? "yes" : "no") << '\n';
    return 0;
}

Engine und Verteilung

Die rohe Ausgabe der Engine ist über einen sehr großen Wertebereich gleichverteilt. Um brauchbare Werte wie einen Würfelwurf zu erhalten, übergeben Sie die Engine an eine Verteilung.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(2024);
    std::uniform_int_distribution<int> die(1, 6);
    std::cout << "rolled " << die(gen) << '\n';
    return 0;
}

Werte verwerfen

discard(n) bewegt die Engine um n Schritte weiter, ohne eine Ausgabe zu erzeugen. Das ist nützlich, um in einer Sequenz vorzuspringen.

#include <iostream>
#include <random>

int main() {
    std::mt19937 a(10), b(10);
    b.discard(2);
    a(); a();
    std::cout << std::boolalpha << (a() == b()) << '\n';
    return 0;
}

Eine Engine wiederverwenden

Erzeugen Sie eine einzige Engine und verwenden Sie sie für alle Zufallswerte in Ihrem Programm wieder. Jedes Mal eine neue Engine zu erzeugen, ist ineffizient und kann die Qualität beeinträchtigen.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(2026);
    std::uniform_int_distribution<int> d10(1, 10);
    int total = 0;
    for (int i = 0; i < 5; ++i) total += d10(gen);
    std::cout << "sum of 5 rolls: " << total << '\n';
    return 0;
}

Tückischer Standard-Seed

Eine per Standardkonstruktor erzeugte Engine verwendet einen festen Standard-Seed und erzeugt daher bei jedem Durchlauf dieselbe Sequenz. Für echte Vielfalt müssen Sie sie mit einem Seed initialisieren (das wird in der nächsten Lektion behandelt).

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen; // default seed: same every run
    std::cout << "first value mod 1000: " << (gen() % 1000) << '\n';
    return 0;
}

Kurztest

Testen Sie Ihr Verständnis von Zufalls-Engines.

Zusammenfassung

Sie haben Zufalls-Engines kennengelernt:

<random> trennt Engines (Bits) von Verteilungen (Form)
std::mt19937 ist die gängige Engine und für einen bestimmten Seed deterministisch
Verwenden Sie eine Engine wieder und initialisieren Sie sie mit einem geeigneten Seed, um echte Vielfalt zu erhalten

Als Nächstes formen Sie die Ausgabe einer Engine mithilfe von Verteilungen.

Häufig gestellte Fragen

Ist die Lektion „Zufallszahlengeneratoren“ kostenlos?

Ja — der vollständige Text von „Zufallszahlengeneratoren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Zufallszahlengeneratoren“?

Zufallsbits erzeugen Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Zufallszahlengeneratoren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy