SRAND

Syntaxe

Paramètres

Description

Cette fonction permet d'initialiser le générateur de nombre aléatoire.

Remarques

• La fonction srand() est utilisée pour définir un point de départ pour la séquence générée par la fonction rand(). La fonction rand() renvoie des nombres pseudo-aléatoires.
• La fonction srand() est généralement utilisé pour permettre à plusieurs exécutions de programme d'utiliser différentes séquences de nombres pseudo-aléatoires en spécifiant différents points de départ. Inversement, vous pouvez également utiliser la fonction srand() pour générer la même séquence pseudo-aléatoire encore et encore en l'appelant avec la même valeur de départ avant de commencer la séquence à chaque fois.
• Nécessité d'appeler srand avant rand : Si srand n'est pas appelée, rand() utilisera une graine par défaut, ce qui produira la même séquence à chaque exécution du programme. Exemple incorrect :
1. // Même séquence de nombres à chaque exécution
2. for (int i = 0; i < 5; i++)
3.     std::cout << rand() << std::endl;

Pour éviter cela, on utilise srand(time(NULL)).

• Utilisation de srand(time(NULL)) pour des nombres plus aléatoires : Une technique courante pour éviter une séquence répétitive est d'utiliser l'horloge système :
1. #include <cstdlib>
2. #include <ctime>
3. srand(time(NULL));

Comme time(NULL) change chaque seconde, la séquence sera différente à chaque exécution.

• Ne pas appeler srand plusieurs fois dans une boucle : Il est inutile (et parfois problématique) d'appeler srand plusieurs fois dans une boucle, car cela réinitialise le générateur à chaque appel. Mauvaise pratique :
1. for (int i = 0; i < 10; i++) {
2.     srand(time(NULL)); // Réinitialisation constante
3.     std::cout << rand() % 100 << std::endl;
4. }

Ici, plusieurs appels à srand(time(NULL)) dans un court laps de temps peuvent produire la même valeur répétée.

• Limitations de rand() et srand() : rand() n'est pas un bon générateur de nombres aléatoires pour des applications exigeantes (cryptographie, simulations scientifiques). Son implémentation varie selon le compilateur et le système d'exploitation. Pour des besoins plus avancés, il est recommandé d'utiliser la bibliothèque <random> introduite en C++11.
• Influence directe sur rand() : srand ne génère pas directement de nombres aléatoires, mais affecte l'état interne du générateur utilisé par rand(). Exemple :
1. srand(42); // Toujours la même séquence
2. std::cout << rand() << std::endl;

Chaque fois qu'on exécute ce code avec la même graine (42), les valeurs retournées par rand() seront identiques.

• Alternatives modernes avec <random>: Depuis C++11, il est recommandé d'utiliser std::mt19937 au lieu de srand et rand(), car il produit de meilleures distributions de nombres. Exemple avec <random> :
1. #include <random>
2. std::mt19937 rng(42); // Générateur plus robuste
3. std::uniform_int_distribution<int> dist(1, 100);
4. std::cout << dist(rng) << std::endl;

Cela permet d'obtenir des nombres aléatoires plus imprévisibles.

• Non thread-safe et non réentrant : srand et rand utilisent un état global, ce qui peut poser problème en programmation multi-processus léger. Si plusieurs processus légers appellent rand(), ils risquent d'interférer et de produire des séquences biaisées. Il est préférable d'utiliser std::random_device ou std::mt19937 pour des applications multi-processus léger.

Voir également

Langage de programmation - C++ - Référence de procédures et fonctions - rand
Langage de programmation - C - Référence de procédures et fonctions - srand

Références

Langage C, Edition Micro-Application, Gehard Willms, 2001, ISBN: 2-7429-2008-0, page 734.
Borland C++ for Windows 4.0, Library Reference, Edition Borland, 1993, Part # BCP1240WW21772, page 249.