NOM

       rand, rand_r, srand - Générateur de nombres pseudoaléatoires

SYNOPSIS

       #include <stdlib.h>

       int rand(void);

       int rand_r(unsigned int *seedp);

       void srand(unsigned int seed);

   Exigences    de    macros    de   test   de   fonctionnalités   pour   la   glibc   (consultez
   feature_test_macros(7)) :

       rand_r() : _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE

DESCRIPTION

       La fonction rand() renvoie un entier pseudoaléatoire entre 0 et RAND_MAX, bornes  incluses
       (c'est-à-dire dans l'intervalle [0, RAND_MAX]).

       La  fonction  srand()  utilise  son  argument  comme  « graine »  pour la génération d'une
       nouvelle séquence  de  nombres  pseudoaléatoires,  qui  seront  fournis  par  rand().  Ces
       séquences sont reproductibles en appelant srand() avec la même valeur de graine.

       Si  aucune  graine  originale  n'est  fournie, la fonction rand() commence en utilisant la
       valeur 1.

       La fonction rand() n'est ni réentrante ni sûre en contexte multithread, car  elle  utilise
       un  état  interne modifié à chaque appel. Il peut s'agir simplement de la valeur de graine
       aléatoire pour l'appel suivant, ou il peut s'agir de quelque chose de plus compliqué. Afin
       d'obtenir  un  comportement  reproductible dans une application multithread, cet état doit
       être stocké dans une variable fournie explicitement ; cela peut être fait en utilisant  la
       fonction réentrante rand_r().

       Comme  rand(), rand_r() renvoie un entier pseudoaléatoire dans l'intervalle [0, RAND_MAX].
       L'argument seedp est un pointeur vers un unsigned int qui est utilisé pour stocker  l'état
       entre  des  appels  successifs.  Si  la  fonction rand_r() est appelée avec la même valeur
       initiale pour l'entier pointé par seedp, et que cette valeur n'est pas modifiée entre  les
       appels, alors la même séquence pseudoaléatoire sera générée.

       La  valeur  pointée  par l'argument seedp de rand_r() ne fournit qu'une donnée très petite
       pour stocker la valeur d'état, cette fonction  sera  donc  un  générateur  pseudoaléatoire
       faible. Essayez donc drand48_r(3) à sa place.

VALEUR RENVOYÉE

       Les  fonctions  rand()  et rand_r() renvoient un nombre entier entre 0 et RAND_MAX, bornes
       incluses. La fonction srand() ne renvoie aucune valeur.

CONFORMITÉ

       Les fonctions rand() et srand() sont conformes à SVr4, BSD 4.3, C89, C99, POSIX.1-2001. La
       fonction  rand_r()  vient  de  POSIX.1-2001.  POSIX.1-2008  marque  rand_r()  comme  étant
       obsolète.

NOTES

       Les versions de rand() et srand()  de  la  bibliothèque  C  de  Linux  utilisent  le  même
       générateur  de  nombres  aléatoires  que  random(3) et srandom(3), ainsi les bits de poids
       faibles sont tout aussi imprévisibles que les bits de poids forts. Ceci n'est pas  le  cas
       avec  les  anciennes  implémentations  de  rand()  ou  d'actuelles implémentations sur des
       systèmes différents, où les bits de poids faibles n'étaient pas « aussi  aléatoires »  que
       ceux de poids forts. N'utilisez pas cette fonction dans des applications conçues pour être
       portables et lorsqu'un bon caractère aléatoire est nécessaire. (Utilisez plutôt random(3))

EXEMPLE

       POSIX.1-2001  fournit  l'exemple  suivant  d'une  implémentation  de  rand()  et  srand(),
       potentiellement   utile  lorsqu'on  a  besoin  de  la  même  séquence  sur  deux  machines
       différentes.

           static unsigned long suivant = 1;

           /* RAND_MAX supposé être égal à 32767 */
           int mon_rand(void) {
               suivant = suivant * 1103515245 + 12345;
               return((unsigned)(suivant/65536) % 32768);
           }

           void mon_srand(unsigned int graine) {
               suivant = graine;
           }

       Le programme suivant peut être utilisé pour afficher la séquence pseudoaléatoire  produite
       par rand() avec une graine donnée.

           #include <stdlib.h>
           #include <stdio.h>

           int
           main(int argc, char *argv[])
           {
               int j, r, nloops;
               unsigned int seed;

               if (argc != 3) {
                   fprintf(stderr, "Usage: %s <seed> <nloops>\n", argv[0]);
                   exit(EXIT_FAILURE);
               }

               seed = atoi(argv[1]);
               nloops = atoi(argv[2]);

               srand(seed);
               for (j = 0; j < nloops; j++) {
                   r =  rand();
                   printf("%d\n", r);
               }

               exit(EXIT_SUCCESS);
           }

VOIR AUSSI

       drand48(3), random(3)

COLOPHON

       Cette  page  fait partie de la publication 3.65 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Depuis    2010,    cette   traduction   est   maintenue   à   l'aide   de   l'outil   po4a
       <http://po4a.alioth.debian.org/> par l'équipe de traduction francophone au sein du  projet
       perkamon <http://perkamon.alioth.debian.org/>.

       Christophe    Blaess    <http://www.blaess.fr/christophe/>   (1996-2003),   Alain   Portal
       <http://manpagesfr.free.fr/> (2003-2006). Nicolas  François  et  l'équipe  francophone  de
       traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>  ou  par  un  rapport  de  bogue   sur   le   paquet
       manpages-fr.

       Vous  pouvez  toujours  avoir  accès  à la version anglaise de ce document en utilisant la
       commande « man -L C <section> <page_de_man> ».

                                         18 janvier 2014                                  RAND(3)