C++ Academy · Leçon

Moteurs aléatoires

Générer des bits aléatoires

Moteurs aléatoires est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Pourquoi <random> ?

L'ancien rand() est de mauvaise qualité et difficile à contrôler. La bibliothèque <random> sépare le hasard en moteurs (sources de bits aléatoires) et en distributions (formes de sortie).

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

Le générateur de Mersenne

std::mt19937 est le moteur le plus courant : rapide, de haute qualité et doté d'une longue période. Le nombre indique la taille de son état en bits.

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

Les moteurs sont déterministes

Avec la même graine, un moteur produit toujours la même séquence. C'est ce qui rend les résultats reproductibles.

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

Appeler le moteur

Un moteur est appelable. Chaque appel à engine() renvoie le prochain entier aléatoire brut de sa plage.

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

Plage du moteur

min() et max() indiquent la plage de valeurs brutes qu'un moteur peut produire.

#include <iostream>
#include <random>

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

Autres moteurs

La bibliothèque propose plusieurs moteurs :

minstd_rand : petit générateur congruent linéaire.
mt19937 : moteur général par défaut.
ranlux48 : qualité supérieure, mais plus lent.

#include <iostream>
#include <random>

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

Moteur 64 bits

Utilisez std::mt19937_64 lorsque vous avez besoin de valeurs aléatoires sur 64 bits, par exemple pour de grands hachages ou de très grandes plages.

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

Moteur ou distribution

La sortie brute du moteur est uniforme sur une plage immense. Pour obtenir des valeurs utiles, comme le résultat d'un lancer de dé, transmettez le moteur à une distribution.

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

Ignorer des valeurs

discard(n) fait avancer le moteur de n étapes sans produire de sortie, ce qui est pratique pour avancer dans une séquence.

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

Réutiliser un seul moteur

Créez un seul moteur et réutilisez-le pour tous les besoins aléatoires de votre programme. Créer un nouveau moteur à chaque fois est inutile et peut réduire la qualité.

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

Piège de la graine par défaut

Un moteur construit par défaut utilise une graine fixe par défaut, et produit donc la même séquence à chaque exécution. Vous devez l'initialiser avec une graine pour obtenir une véritable variété (ce point sera abordé dans la prochaine leçon).

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

Vérification rapide

Évaluez votre compréhension des moteurs aléatoires.

Récapitulatif

Vous avez étudié les moteurs aléatoires :

<random> sépare les moteurs (bits) des distributions (forme)
std::mt19937 est le moteur de référence ; il est déterministe pour une graine donnée
réutilisez un seul moteur et initialisez-le correctement avec une graine pour obtenir une véritable variété

Ensuite, vous façonnerez la sortie du moteur à l'aide de distributions.

Questions Fréquemment Posées

La leçon « Moteurs aléatoires » est-elle gratuite ?

Oui — le texte complet de « Moteurs aléatoires » 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 « Moteurs aléatoires » ?

Générer des bits aléatoires 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 1 sur 4.

Combien de temps prend la leçon « Moteurs aléatoires » ?

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

← Retour à C++ Academy