What difference between rand() and random() functi

问题:

Once, my teacher taught me to use randomize() and random() function for generating pseudorandom numbers in C++ Builder. Now I prefer working in VS 2012, but when I tried to use these functions there it says that "identifier not found", even when I added #include <stdlib.h>. After some time of Googling I found that there are also rand() and srand() functions. What is the difference between them and which is it better to use?

回答1:

randomize() and random() are not part of the standard library. Perhaps your teacher wrote functions with these names for use in your class, or maybe you really mean random() and srandom() which are part of POSIX and not available on Windows. rand() and srand() are part of the standard library and will be provided by any standard conforming implementation of C++.

---

You should avoid rand() and srand() and use the new C++11 <random> library. <random> was added as part of the C++11 standard (and VS2012 does provide it).

Video explaining why: rand() Considered Harmful

• rand() is typically a low quality pRNG and not suitable for applications that need a reasonable level of unpredictability. <random> provides a variety of engines with different characteristics suitable for many different use cases.

• Converting the results of rand() into a number you can use directly usually relies on code that is difficult to read and easy to get wrong, whereas using <random> distributions is easy and produces readable code.

• The common methods of generating values in a given distribution using rand() further decrease the quality of the generated data. % generally biases the data and floating point division still produces non-uniform distributions. <random> distributions are higher quality as well as more readable.

• rand() relies on a hidden global resource. Among other issues this causes rand() to not be thread safe. Some implementations make thread safety guarantees, but this is not required standard. Engines provided by <random> encapsulate pRNG state as objects with value semantics, allowing flexible control over the state.

• srand() only permits a limited range of seeds. Engines in <random> can be initialized using seed sequences which permit the maximum possible seed data. seed_seq also implements a common pRNG warm-up.

---

example of using <random>:

#include <iostream>
#include <random>

int main() {
  // create source of randomness, and initialize it with non-deterministic seed
  std::random_device r;
  std::seed_seq seed{r(), r(), r(), r(), r(), r(), r(), r()};
  std::mt19937 eng{seed};

  // a distribution that takes randomness and produces values in specified range
  std::uniform_int_distribution<> dist(1,6);

  for (int i=0; i<100; ++i) {
    std::cout << dist(eng) << '\n';
  }
}

回答2:

Although there are (obviously, above) people who will assert with religious fervor that rand() is bad and random() is not, it turns out that your mileage may vary. Here's the gcc answer to the question of "What's the difference...", as supplied by the gcc version of stdlib.h (emphasis added):

/* These are the functions that actually do things. The random',srandom', initstate' andsetstate' functions are those from BSD Unices. The rand' andsrand' functions are required by the ANSI standard. We provide both interfaces to the same random number generator. / / Return a random long integer between 0 and RAND_MAX inclusive. */

回答3:

It looks like you were using C-style functions, even though your question is labeled C++. Also, stdlib.h is a header file from C standard library. There's no such functions are random() and randomize() in C standard library. The C standard library has rand() and srand().

If you were using random() or something like that through stdlib.h, it must have been some non-standard library extension in Borland compiler package.

So, if you want to stick to C-style standard functions, that would be, again, rand() and srand(). But if you are writing in C++, you might have better (and more appropriate) options in C++ standard library.

回答4:

srand() is the C Standard library implementation for seeding the (pseudo) random number generator. rand() is the (pseudo) random number generator in the C Standard Library.

C++ has implemented a newer (pseudo) random number generator in the <random> header file, which has a variety of different engines to use: http://en.cppreference.com/w/cpp/numeric/random

回答5:

Functions rand() and random() are either defined by POSIX since at least POSIX.1-2001 (and randomize() is not standardized).

On older rand() implementations, and on current implementations on different systems, the lower-order bits are much less random than the higher-order bits.

When available, random() does not suffer of this issue.

In add, modern version of rand() use the same random number generator as random(). So rand() may be correct, but it is not garanteed.

So, always use random() instead of rand(). If random() is not available on your operating system, ask to operating system developers to provide newer standards API implementation (2001 standard is now old enough to expect any system to provide it).

回答6:

I am not familiar with randomize() and random() but they are not part of the standard library. You should avoid using rand() this video explains why using rand() is considered harmful.

You should be using the random header introduced in C++11, here is example using both std::uniform_real_distribution and std::uniform_int_distribution:

#include <iostream>
#include <random>

int main()
{
    std::random_device rd;

    std::mt19937 e2(rd());

    std::uniform_int_distribution<> dist(1, 6);
    std::uniform_real_distribution<> distReal(1, 6);

    for( int i = 0 ; i < 10; ++i )
    {
       std::cout << dist(e2) << ",";
    }
    std::cout << std::endl ;

    for( int i = 0 ; i < 10; ++i )
    {
       std::cout << distReal(e2) << ",";
    }
    std::cout << std::endl ;

    return 0 ;
}

回答7:

This is a work-around using random numbers form outside of c++.

This is the original program in C, copied from "http://www.programmingsimplified.com/" This program does not run because the " temp1 = 1 + random ( 588 );" "temp2 = 1 + random ( 380 );" statements do not work. 'random' is not a function of graphics.h, conio.h, or stdlib.h Nor, does it work if you include random.h. Below this listing is a work-around for the random function.

#include<graphics.h>
#include<conio.h>
#include<stdlib.h>
main()
{
   int gd = DETECT, gm, area, temp1, temp2, left = 25, top = 75;
   void *p;
   initgraph(&gd,&gm,"C:\\TC\\BGI");

   setcolor(YELLOW);
   circle(50,100,25);
   setfillstyle(SOLID_FILL,YELLOW);
   floodfill(50,100,YELLOW);

   setcolor(BLACK);
   setfillstyle(SOLID_FILL,BLACK);
   fillellipse(44,85,2,6);
   fillellipse(56,85,2,6);

   ellipse(50,100,205,335,20,9);
   ellipse(50,100,205,335,20,10);
   ellipse(50,100,205,335,20,11);

   area = imagesize(left, top, left + 50, top + 50);
   p = malloc(area);

   setcolor(WHITE);
   settextstyle(SANS_SERIF_FONT,HORIZ_DIR,2);
   outtextxy(155,451,"Smiling Face Animation");

   setcolor(BLUE);
   rectangle(0,0,639,449);

   while(!kbhit())
   {
      temp1 = 1 + random ( 588 );
      temp2 = 1 + random ( 380 );

      getimage(left, top, left + 50, top + 50, p);
      putimage(left, top, p, XOR_PUT);
      putimage(temp1 , temp2, p, XOR_PUT);
      delay(100);
      left = temp1;
      top = temp2;
   }

   getch();
   closegraph();
   return 0;
}

The random numbers are generated with a simple MS Excel macro, listed here:

Sub Macro1()
Dim i
For i = 1 To 400
Randomize

Range("a" & i) = Int(Rnd * 588) + 1
Range("b" & i) = Int(Rnd * 380) + 1

Next i
End Sub

This generates 2 columns of random numbers. Each column is copied and pasted into its own *.txt file , i.e. rnd1.txt and rnd2.txt and placed in a directory where they can be accessed by the c++ program that follows. Substitute the "c:\PATH\rnd1.txt" and "C:\PATH\rnd2.txt" with the correct path.

#include<iostream>
#include<fstream> 
#include<graphics.h>

using namespace std;
 int i,j,k;
int main(int argc, char** argv) {
   std::ifstream infile1;
   infile1.open("c:\\PATH\\rnd1.txt",ios::in);
   ifstream infile2;
   infile2.open("c:\\PATH\\rnd2.txt",ios::in);
   int gd = DETECT, gm, area, temp1, temp2, left = 25, top = 75;
   void *p;
   initgraph(&gd,&gm,"C:\\TC\\BGI");

   setcolor(YELLOW);
   circle(50,100,25);
   setfillstyle(SOLID_FILL,YELLOW);
   floodfill(50,100,YELLOW);

   setcolor(BLACK);
   setfillstyle(SOLID_FILL,BLACK);
   fillellipse(44,85,2,6);
   fillellipse(56,85,2,6);

   ellipse(50,100,205,335,20,9);
   ellipse(50,100,205,335,20,10);
   ellipse(50,100,205,335,20,11);

   area = imagesize(left, top, left + 50, top + 50);
   p = malloc(area);

   setcolor(WHITE);
   settextstyle(SANS_SERIF_FONT,HORIZ_DIR,2);
   outtextxy(155,451,"Smiling Face Animation ");

   setcolor(BLUE);
   rectangle(0,0,639,449);

   while(!kbhit())
   {
      infile1 >> j;
      temp1 = j;
      infile2 >> k;
      temp2 = k;
      if(infile2.eof()) {
       closegraph();
       void close();
       return 0;
        }                
      getimage(left, top, left + 50, top + 50, p);
      putimage(left, top, p, XOR_PUT);
      putimage(temp1 , temp2, p, XOR_PUT);
      delay(100);
      left = temp1;
      top = temp2;
      }

      }

This program will run for about 40 seconds and then terminate.