C++ Academy · Les

Correct seeden

Genereer reproduceerbare willekeurigheid

Les 3 van 413 stappen

Correct seeden is een gratis C++ Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Wat is seeden?

Een seed is de beginstatus van een generator. Met dezelfde seed krijg je opnieuw dezelfde reeks; met een andere seed krijg je een andere reeks.

#include <iostream>
#include <random>

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

Een vaste seed voor reproduceerbaarheid

Een constante seed maakt resultaten herhaalbaar, wat ideaal is voor toetsen en foutopsporing.

#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 levert niet-deterministische seeds vanuit het besturingssysteem. Gebruik deze één keer om je generator te initialiseren.

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

Eén keer seeden, hergebruiken

Seed de generator bij het opstarten één keer. Opnieuw seeden vóór elke trekking verslechtert de kwaliteit van de willekeur.

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

De valkuil van seeden met tijd

Seeden met time(nullptr) verandert slechts één keer per seconde, waardoor programma's die tegelijk worden gestart dezelfde reeks krijgen. Gebruik liever 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;
}

Seeden met seed_seq

Een generator heeft veel interne toestand. std::seed_seq verspreidt meerdere seedwaarden over die volledige toestand voor een betere initialisatie.

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

Waarden van random_device combineren

Verzamel voor seeden van hoge kwaliteit meerdere waarden uit random_device in een 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;
}

Expliciet opnieuw seeden

Je kunt een bestaande generator resetten met seed(value) om de reeks vanaf een bekend punt opnieuw te 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;
}

Toestand opslaan en herstellen

Je kunt een generator naar een stroom schrijven en er weer uit lezen, zodat je een exacte willekeurige toestand kunt opslaan en hervatten.

#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 is niet reproduceerbaar

Omdat random_device niet-deterministisch is, mag je deze nooit gebruiken wanneer je een uitvoering wilt reproduceren. Gebruik daarvoor een vaste 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;
}

Een herbruikbare generator

Een veelgebruikt patroon verbergt een generator met seed achter een kleine hulpfunctie, zodat de rest van de code alleen om getallen hoeft te vragen.

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

Korte toets

Toets je begrip van seeden.

Beantwoord dit in de interactieve les

Overzicht

Je hebt geleerd hoe je op de juiste manier seedt:

een vaste seed zorgt voor reproduceerbare uitvoeringen; std::random_device zorgt voor unieke uitvoeringen
seed één keer bij het opstarten, niet vóór elke trekking; vermijd de onnauwkeurige time()-seed
seed_seq verspreidt entropie over de generator, en de toestand van de generator kan via streams worden opgeslagen en hersteld

Vervolgens pas je dit allemaal toe op praktische voorbeelden.

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Correct seeden” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Correct seeden”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Correct seeden”?

Genereer reproduceerbare willekeurigheid Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Correct seeden”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy