http://en.cppreference.com/w/cpp/numeric/random

Un nombre aléatoire est un nombre dont la valeur est choisit au hasard. Ils sont utilisé dans de nombreux contextes, par exemple dans un jeu vidéo (pour avoir un comportement non prédictible), en cryptographie (pour encoder des informations), dans les tests automatisés du code (pour vérifier le comportement d'un programme avec des valeurs indéterminées). Vous verrez dans différents projets de ce cours des cas d'utilisation des nombres aléatoires.

Tirer des nombres aléatoires peut sembler être une tâche facile. On peut par exemple prendre un dé de jeux (non pipé) à six faces et le lancer plusieurs fois pour obtenir une série de nombres aléatoires compris entre un et six. On peut également lancer une pièce de monnaie pour obtenir des nombres aléatoires valant zéro (Pile) ou un (Face).

La difficulté vient du fait qu'il est facile d'obtenir des suites de nombres dont on n'arrive pas à prédire la prochaine valeur, mais qui présente quand même des propriétés mathématiques prédictibles. Si on additionne par exemple la valeur de deux dés, on aura un nombre aléatoire compris entre 2 et 12. Mais la probabilité d'obtenir un 12 est bien inférieure (1 chance sur 36) à la probabilité d'obtenir un 7 (12 chances sur 36).

Quand vous jouez à un jeu de société, ce n'est pas très important que les nombres obtenus ne soient pas parfaitement aléatoire (et c'est de toute façon intégré comme composante du jeu). Mais lorsque les nombres aléatoires permettent de crypter des données importantes ou sécuriser une numéro de carte bancaire, la moindre propriété mathématique prédictible sur une série de nombres aléatoires peut permettre de contourner ces sécurités.

Il ne donc pas simplement que les nombres semblent aléatoires. Il faut le prouver mathématiquement. (Et bien sûr, cela sort complètement du domaine de ce livre, ces sont des travaux de recherches très pointus).

Pour en revenir à la programmation, on peut se poser une question : comment générer des nombres parfaitement aléatoires sur un ordinateur ? Ce n'est pas si simple, puisqu'un ordinateur est prévu pour être parfaitement prédictible (la même suite d'instructions avec les mêmes données produira le même résultat).

Heureusement, il existe plusieurs approches possibles.

La bibliothèque standard fournit plusieurs fonctionnalités pour générer des nombres aléatoires, en utilisant différents algorithmes. L'ensemble de ces fonctionnalités sont accessibles en utilisant le fichier d'en-tête random (“aléatoire” en anglais).

#include <random>

La documentation est accessible en ligne : Pseudo-random number generation, n'hésitez pas à la lire rapidement.

Les fonctionnalités de génération de nombres aléatoires se décomposent en trois catégories :

• le générateur de nombres aléatoires non déterministe ;
• les générateurs de nombres aléatoires déterministes (nombres pseudo-aléatoires) ;
• les générateurs de distributions statistiques.

L'utilisation d'un générateur aléatoire est relativement simple, même si cela utilise un syntaxe que vous n'avez pas encore vu. Il faut créer une variable utilisant le générateur comme type, puis appeler cette variable comme une fonction. On parle d'“objet appelable” (callable en anglais). En pratique, la syntaxe est la suivante :

CallableType myVariable{};              // créé une variable de type CallableType
auto result = myVariable(arg1, arg2);   // appel cette variable comme une fonction

Le type CallableType représente n'importe quel type qui permet de créer un objet appelable. Comme n'importe quelle fonction, un objet appelable peut prendre des arguments en entrée et retourner une valeur.

Le générateur non déterministe est la classe std::random_device. Cet objet sera appelé sans utiliser d'argument, et retourne un entier aléatoire à chaque fois qu'il est appelé.

main.cpp

#include <iostream>
#include <random>
 
int main() {
    std::random_device rd{};            // création du générateur
 
    std::cout << rd() << std::endl;     // génération d'un nombre aléatoire
    std::cout << rd() << std::endl;     // génération d'un nombre aléatoire
    std::cout << rd() << std::endl;     // génération d'un nombre aléatoire
}

Ce code permet de générer trois nombres aléatoires, qui seront différents à chaque fois que vous relancez le programme. Par exemple, cela peut donner la série suivante :

3555021123
4089866385
3885819577

Ces nombres pseudo-aléatoires seront en fait le résultat d'un algorithme complexe. Cet algorithme sera initialisée avec une valeur quelconque (graine ou seed) et produira une suite de nombres pseudo-aléatoires à chaque appel.