C + + random number

Standard library <cstdlib> (included in <iostream>) provides two functions to help generate pseudo-random numbers:

function one: int rand (void);
Returns a random integer between [seed, Rand_max (0X7FFF)), starting with the seed specified in Srand (seed).

function two: void Srand (unsigned seed);
The parameter seed is the seed of Rand (), which is used to initialize the starting value of rand ().

It can be thought that rand () will look at each time it is called:
1) If the user has previously called srand (SEED) and assigned a value to seed, it will automatically call
Srand (Seed) initializes its starting value at once.
2) If the user has not called srand (seed) before, it will automatically call Srand (1) once.

According to the 1th above we can draw:
1) If you want Rand () to produce a different value each time the program runs, you must give the seed in Srand a variable value, which must be different every time the program runs (such as the elapsed time so far).
2) Otherwise, if you specify a value for seed, RAND () will produce the same value each time the program runs, although this value will be a randomly obtained value between [seed, Rand_max (0X7FFF)).
3) if Srand (seed) is not called before the call to Rand (), the effect will be the same as calling Srand (1) and then calling Rand () (1 is also a fixed value).

To give a few examples, suppose we want to get a random integer between 0~6 (excluding 6 itself):

Example one, do not specify seed:
for (int i=0;i<10;i++) {
Ran_num=rand ()% 6;
cout<<ran_num<< "";
}
Output per run: 5 5 4 4 5 4 0 0 4 2

Example two, specifying seed as a value of 1:
Srand (1);
for (int i=0;i<10;i++) {
Ran_num=rand ()% 6;
cout<<ran_num<< "";
}
Output per run: 5 5 4 4 5 4 0 0 4 2
The result is exactly the same as in example one.

Example three, specifying seed as a value of 6:
Srand (6);
for (int i=0;i<10;i++) {
Ran_num=rand ()% 6;
cout<<ran_num<< "";
}
Output per run: 4 1 5 1 4 3 4 4 2 2
The random values are also between [0,6], with values different from Srand (1), but the results are the same for each run.

Example four, specifying the time (in seconds) that seed has elapsed for the current system: time_t times (0):
#include <ctime>
...
Srand ((unsigned) time (0));
for (int i=0;i<10;i++) {
Ran_num=rand ()% 6;
cout<<ran_num<< "";
}
First run-time output: 0 1 5 4 5 0 2 3 4 2
Second time: 3 2 3 0 3 5 5 2 2 3
In summary, each run will be different, because the time to start the program varies (the interval must be greater than 1 seconds?). See below).

About time_t Time (0):

time_t is defined as a long integer that returns the amount of time, in seconds, that has elapsed since January 1, 1970, 0 minutes and 0 seconds to date. For example, suppose the output:
Cout<<time (0);
The value is approximately 1169174701, approximately equal to 37 (years) multiplied by 365 (days) by 24 (hours) by 3600 (seconds) (not counted on the day of the month).

In addition, about Ran_num = rand ()% 6,

It is necessary to model the return value of rand () with 6 in order to ensure that the purpose is randomly grumble between [0,6], otherwise the return value of rand () may itself be huge.
A common formula is:
To obtain a random integer between [a, b], use (rand ()% (b-a)) + A (the resulting value will contain a does not contain a).
In case A is 0, the abbreviation is rand ()% B.

Finally, about pseudo-random floating-point numbers:

With RAND ()/double (Rand_max) you can get the floating-point number between 0~1 (note that the formula differs from the integral type, is divided, not modulo), for example:
Double ran_numf=0.0;
Srand ((unsigned) time (0));
for (int i=0;i<10;i++) {
RAN_NUMF = rand ()/(double) (Rand_max);
cout<<ran_numf<< "";
}
Operation results are: 0.716636, 0.457725, ... A floating-point number between 10 0~1, each with a different result.

If you want to take a larger range of random floating-point numbers, such as 1~10, you can
RAND ()/(double) (RAND_MAX) changed to Rand ()/(double) (RAND_MAX/10)
Operation results are: 7.19362, 6.45775, ... A floating-point number between 10 1~10, each with a different result.
As for the situation of 100,1000, so the analogy.

The above is not the best way to implement pseudo-random floating-point numbers, but can be used.

=================================================================================

A general expression formula for generating a certain range of random numbers
To obtain a random integer [A, b], use (rand ()% (b-a)) + A;
To obtain a random integer [A, b], use (rand ()% (b-a+1)) + A;
To obtain a random integer (A, b], use (rand ()% (b-a)) + A + 1;
General formula: A + rand ()% n; where a is the starting value and N is the range of integers.
To get a random integer between A and B, another representation: A + (int) b * rand ()/(Rand_max + 1).
To obtain a floating-point number between 0~1, you can use RAND ()/double (Rand_max)

Http://www.cppblog.com/Niino/archive/2008/08/16/59042.html

Http://www.cnblogs.com/afarmer/archive/2011/05/01/2033715.html

C + + random number