Comment puis-je obtenir le code source pour rand () (C ++)?

Je suis nouveau en programmation.

Je veux savoir exactement ce que rand ().

Recherche seulement donne des exemples sur son utilisation. Mais aucun d'expliquer chaque étape de la façon dont la fonction génère un nombre aléatoire. Ils traitent rand() comme blackbox.

Je veux savoir ce que rand() est en train de faire; chaque étape.

Est-il une ressource qui va me permettre de voir exactement ce que rand ()?
C'est tout ce qui est open-source n'est-ce pas? Je me contenterai pour le démontage, si il n'y a pas de source.

Je sais qu'il renvoie un nombre aléatoire, mais comment fait-il de générer un nombre? Je veux voir chaque étape.

Merci.

source d'informationauteur BBedit

  2. 16

    Ici est l'actuelle mise en œuvre de la glibc:

    /* Return a random integer between 0 and RAND_MAX.  */
int
rand (void)
{
  return (int) __random ();
}

    Ce n'est pas beaucoup d'aide, mais __random appelle éventuellement __aléatoire_r:

    /* If we are using the trivial TYPE_0 R.N.G., just do the old linear
   congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
   same in all the other cases due to all the global variables that have been
   set up.  The basic operation is to add the number at the rear pointer into
   the one at the front pointer.  Then both pointers are advanced to the next
   location cyclically in the table.  The value returned is the sum generated,
   reduced to 31 bits by throwing away the "least random" low bit.
   Note: The code takes advantage of the fact that both the front and
   rear pointers can't wrap on the same call by not testing the rear
   pointer if the front one has wrapped.  Returns a 31-bit random number.  */

int
__random_r (buf, result)
     struct random_data *buf;
     int32_t *result;
{
  int32_t *state;

  if (buf == NULL || result == NULL)
    goto fail;

  state = buf->state;

  if (buf->rand_type == TYPE_0)
    {
      int32_t val = state[0];
      val = ((state[0] * 1103515245) + 12345) & 0x7fffffff;
      state[0] = val;
      *result = val;
    }
  else
    {
      int32_t *fptr = buf->fptr;
      int32_t *rptr = buf->rptr;
      int32_t *end_ptr = buf->end_ptr;
      int32_t val;

      val = *fptr += *rptr;
      /* Chucking least random bit.  */
      *result = (val >> 1) & 0x7fffffff;
      ++fptr;
      if (fptr >= end_ptr)
    {
      fptr = state;
      ++rptr;
    }
      else
    {
      ++rptr;
      if (rptr >= end_ptr)
        rptr = state;
    }
      buf->fptr = fptr;
      buf->rptr = rptr;
    }
  return 0;

 fail:
  __set_errno (EINVAL);
  return -1;
}
  3. 3

    Vous pouvez parcourir le code source pour les différentes implémentations de la norme.

    La question a été répondue avant, vous pourriez trouver ce que vous cherchez au Quels algorithmes sont utilisés pour des C rand()?

    Cette réponse fournit le code pour la glibc de la mise en œuvre de rand()

  4. 2

    Je suppose, CETTE est ce que vous cherchez. Il contient une explication détaillée de la fonction random, et C très simple programme pour comprendre l'algo.

    Edit:

    Vous devriez vérifier CETTE. Un double possible.

  5. 2

    Bien, je crois que rand est à partir de la bibliothèque standard C, pas du C++ standard library. Il n'existe pas de mise en œuvre de la bibliothèque, il y a plusieurs.

    Vous pouvez aller quelque part, comme cette page pour afficher le code source de la glibc, la bibliothèque c utilisée sur la plupart des distributions Linux. Pour la glibc vous trouver dans les fichiers source en vertu de la stdlib comme rand.c et random.c.

    Une mise en œuvre différente, comme uClibc pourrait être plus facile à lire. Essayer ici en vertu de la libc/stdlib dossier.

  6. 1

    Le plus simple raisonnablement bon nombre pseudo-aléatoire générateurs sont Linéaire Des Générateurs À Congruence (LCGs). Ces sont des itérations d'une formule telle que

    X_{n+1} = (a * X_n  +  c) modulo m

    Les constantes a, c et m sont choisis pour donné imprévisible séquences. X_0 est la valeur de départ aléatoire. De nombreux autres algorithmes existent, mais c'est probablement suffisant pour vous allez.

    Vraiment bon pseudo-générateurs de nombres aléatoires sont plus complexes, comme la Mersenne Twister.