0Pricing
C++ Academy · Leçon

Initialiser correctement le générateur

Obtenir un aléatoire reproductible

Initialiser correctement le générateur est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Que signifie « seed » ?

Un seed est l’état initial d’un moteur. Le même seed reproduit la même séquence ; un seed différent en produit une autre.

#include <iostream>
#include <random>

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

Seed fixe pour la reproductibilité

Un seed constant rend les résultats reproductibles, ce qui est idéal pour les tests et le débogage.

#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 fournit des seeds non déterministes provenant du système d’exploitation. Utilisez-le une seule fois pour initialiser votre moteur.

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

Initialiser une fois, réutiliser

Initialisez le moteur une seule fois au démarrage. Réinitialiser le seed avant chaque tirage dégrade la qualité de l’aléatoire.

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

Le piège du seed basé sur l’heure

Initialiser le moteur avec time(nullptr) ne change le seed qu’une fois par seconde ; les programmes démarrés simultanément obtiennent donc la même séquence. Préférez 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;
}

Initialisation avec seed_seq

Un moteur possède un grand état interne. std::seed_seq répartit plusieurs valeurs de seed dans l’ensemble de cet état pour améliorer l’initialisation.

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

Combinaison de valeurs de random_device

Pour une initialisation de qualité, recueillez plusieurs valeurs de random_device dans un 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;
}

Réinitialiser explicitement le seed

Vous pouvez réinitialiser un moteur existant avec seed(value) afin de redémarrer sa séquence depuis un point connu.

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

Enregistrer et restaurer l’état

Un moteur peut être écrit dans un flux, puis relu, ce qui vous permet d’enregistrer et de reprendre un état aléatoire exact.

#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 n’est pas reproductible

Comme random_device est non déterministe, ne l’utilisez jamais lorsque vous devez reproduire une exécution. Utilisez plutôt un seed fixe.

#include <iostream>
#include <random>

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

Un générateur réutilisable

Un schéma courant encapsule un moteur initialisé avec un seed derrière un petit utilitaire, afin que le reste du code se contente de demander des nombres.

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

Vérification rapide

Testez votre compréhension de l’initialisation avec un seed.

Récapitulatif

Vous avez appris à initialiser correctement les moteurs :

  • un seed fixe produit des exécutions reproductibles ; std::random_device en produit de différentes
  • initialisez le moteur une seule fois au démarrage, et non à chaque tirage ; évitez le seed grossier de time()
  • seed_seq répartit l’entropie dans le moteur, et son état peut être enregistré ou restauré au moyen de flux

Ensuite, vous appliquerez tout cela à des exemples pratiques.

Questions Fréquemment Posées

La leçon « Initialiser correctement le générateur » est-elle gratuite ?

Oui — le texte complet de « Initialiser correctement le générateur » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Initialiser correctement le générateur » ?

Obtenir un aléatoire reproductible Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Initialiser correctement le générateur » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Moteurs aléatoires
  2. Distributions
  3. Initialiser correctement le générateur
  4. Exemples pratiques
← Retour à C++ Academy