C++ Academy · Lektion

Richtig initialisieren

Reproduzierbare Zufallszahlen erzeugen

Richtig initialisieren ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Was bedeutet Seeding?

Ein Seed ist der Anfangszustand einer Engine. Derselbe Seed erzeugt dieselbe Sequenz erneut; ein anderer Seed erzeugt eine andere Sequenz.

#include <iostream>
#include <random>

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

Fester Seed für Reproduzierbarkeit

Ein konstanter Seed macht Ergebnisse reproduzierbar und eignet sich daher ideal für Tests und Debugging.

#include <iostream>
#include <random>

int main() {
    auto run = [](unsigned s) {
        std::mt19937 g(s);
        return g() % 1000;
    };
    std::cout << run(42) << ' ' << run(42) << '\n';
    return 0;
}

std::random_device

std::random_device liefert nichtdeterministische Seeds aus dem Betriebssystem. Verwenden Sie ihn einmal, um Ihre Engine zu initialisieren.

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> d(1, 6);
    std::cout << "a roll: " << d(gen) << '\n';
    return 0;
}

Einmal initialisieren, wiederverwenden

Initialisieren Sie die Engine beim Programmstart ein einziges Mal. Eine erneute Initialisierung vor jeder Ziehung verschlechtert die Zufallsqualität.

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 gen(rd());            // seed once
    std::uniform_int_distribution<int> d(1, 100);
    for (int i = 0; i < 3; ++i) std::cout << d(gen) << ' ';
    std::cout << '\n';
    return 0;
}

Die Tücke des Zeit-Seeds

Das Initialisieren mit time(nullptr) ändert sich nur einmal pro Sekunde. Daher erhalten gleichzeitig gestartete Programme dieselbe Sequenz. Bevorzugen Sie random_device.

#include <iostream>
#include <random>
#include <ctime>

int main() {
    std::mt19937 gen(static_cast<unsigned>(std::time(nullptr)));
    std::cout << "seeded from time (coarse)\n";
    std::cout << (gen() % 100) << '\n';
    return 0;
}

Initialisieren mit seed_seq

Eine Engine besitzt umfangreichen internen Zustand. std::seed_seq verteilt mehrere Seed-Werte über den gesamten Zustand und sorgt so für eine bessere Initialisierung.

#include <iostream>
#include <random>

int main() {
    std::seed_seq seq{1, 2, 3, 4};
    std::mt19937 gen(seq);
    std::cout << (gen() % 1000) << '\n';
    return 0;
}

Werte aus random_device kombinieren

Für eine hochwertige Initialisierung sammeln Sie mehrere Werte aus random_device in einer seed_seq.

#include <iostream>
#include <random>
#include <array>

int main() {
    std::random_device rd;
    std::array<unsigned, 4> seeds{rd(), rd(), rd(), rd()};
    std::seed_seq seq(seeds.begin(), seeds.end());
    std::mt19937 gen(seq);
    std::cout << "well-seeded engine ready\n";
    std::cout << (gen() % 100) << '\n';
    return 0;
}

Erneut explizit initialisieren

Sie können eine vorhandene Engine mit seed(value) zurücksetzen, um ihre Sequenz an einem bekannten Punkt neu zu starten.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(1);
    unsigned first = gen();
    gen.seed(1);             // restart
    std::cout << std::boolalpha << (gen() == first) << '\n';
    return 0;
}

Zustand speichern und wiederherstellen

Eine Engine kann in einen Stream geschrieben und daraus wieder eingelesen werden. So können Sie einen exakten Zufallszustand speichern und fortsetzen.

#include <iostream>
#include <sstream>
#include <random>

int main() {
    std::mt19937 gen(5);
    std::ostringstream save; save << gen;
    unsigned expected = gen();
    std::istringstream load(save.str());
    std::mt19937 restored; load >> restored;
    std::cout << std::boolalpha << (restored() == expected) << '\n';
    return 0;
}

random_device ist nicht reproduzierbar

Da random_device nichtdeterministisch ist, sollten Sie es niemals verwenden, wenn Sie einen Lauf reproduzieren müssen. Verwenden Sie dafür einen festen Seed.

#include <iostream>
#include <random>

int main() {
    const unsigned FIXED = 2026;
    std::mt19937 gen(FIXED); // reproducible across runs
    std::cout << (gen() % 10000) << '\n';
    return 0;
}

Ein wiederverwendbarer Generator

Ein häufig verwendetes Muster kapselt eine initialisierte Engine hinter einer kleinen Hilfsfunktion, sodass der restliche Code einfach Zahlen anfordern kann.

#include <iostream>
#include <random>

int roll(std::mt19937& gen) {
    std::uniform_int_distribution<int> d(1, 6);
    return d(gen);
}

int main() {
    std::mt19937 gen(2026);
    std::cout << roll(gen) << ' ' << roll(gen) << '\n';
    return 0;
}

Kurze Überprüfung

Testen Sie Ihr Verständnis des Seedings.

Zusammenfassung

Sie haben die korrekte Initialisierung kennengelernt:

Ein fester Seed sorgt für reproduzierbare Läufe; std::random_device erzeugt einzigartige
Initialisieren Sie die Engine beim Programmstart einmal, nicht vor jeder Ziehung, und vermeiden Sie den ungenauen time()-Seed
seed_seq verteilt Entropie über die Engine, und der Zustand der Engine kann über Streams gespeichert und wiederhergestellt werden

Als Nächstes wenden Sie all dies auf praktische Beispiele an.

Häufig gestellte Fragen

Ist die Lektion „Richtig initialisieren“ kostenlos?

Ja — der vollständige Text von „Richtig initialisieren“ 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 „Richtig initialisieren“?

Reproduzierbare Zufallszahlen 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 3 von 4.

Wie lange dauert die Lektion „Richtig initialisieren“?

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