I'm trying to make a game with dice, and I need to have random numbers in it (to simulate the sides of the die. I know how to make it between 1 and 6). Using

```
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;
int main()
{
srand((unsigned)time(0));
int i;
i = (rand()%6)+1;
cout << i << "n";
}
```

doesn't work very well, because when I run the program a few times, here's the output I get:

```
6
1
1
1
1
1
2
2
2
2
5
2
```

So I want a command that will generate a *different* random number each time, not the same one 5 times in a row. Is there a command that will do this?

The most fundamental problem of your test application is that you call

`srand`

once and then call`rand`

one time and exit.The whole point of

`srand`

function is to initializethe sequence of pseudo-random numberswith a random seed.It means that if you pass

the same valueto`srand`

in two different applications (with the same`srand`

/`rand`

implementation) thenyou will get exactly the same sequenceof`rand()`

values read after that in both applications.However in your example application pseudo-random sequence consists only of one element - the first element of a pseudo-random sequence generated from seed equal to current time of

`1 sec`

precision. What do you expect to see on output then?Obviously when you happen to run application on the same second - you use the same seed value - thus your result is the same of course (as Martin York already mentioned in a comment to the question).

Actually you should call

`srand(seed)`

one time and then call`rand()`

many timesand analyze that sequence - it should look random.AMENDMENT 1 - example code:OK I get it. Apparently verbal description is not enough (maybe language barrier or something... :) ).

Old-fashioned C code example based on the same

`srand()/rand()/time()`

functions that was used in the question:^^^

THATsequence from a single run of the program is supposed to look random.Please NOTEthat I don't recommend to use`rand`

/`srand`

functions in production for the reasons explained below and I absolutely don't recommend to use function`time`

as a random seed for the reasons that IMO already should be quite obvious. Those are fine for educational purposes and to illustrate the point sometimes but for any serious use they are mostly useless.AMENDMENT 2 - detailed explanation:It is important to understand that as of now there is

noneC or C++ standard features (library functions or classes) producing actually random data definitively (i.e. guaranteed by the standard to be actually random). The only standard feature that approaches this problem is std::random_device that unfortunately still does not provide guarantees of actual randomness.Depending on the nature of application you should first decide if you really need truly random (unpredictable) data. Notable case

when you do most certainly need true randomnessis information security - e.g. generating symmetric keys, asymmetric private keys, salt values, security tokens, etc.However security-grade random numbers is a separate industry worth a separate article.

In most cases Pseudo-Random Number Generator is sufficient - e.g. for scientific simulations or games. In some cases consistently defined pseudo-random sequence is even required - e.g. in games you may choose to generate exactly same maps in runtime to avoid storing lots of data in your distribution.

The original question and reoccurring multitude of identical/similar questions (and even many misguided "answers" to them) indicate that first and foremost it is important to distinguish random numbers from pseudo-random numbers AND to understand what is pseudo-random number sequence in the first place AND to realize that pseudo-random number generators are NOT used the same way you could use true random number generators.

^^^

THAT kind of intuitive expectations IS VERY WRONG and harmfulin all cases involving Pseudo-Random Number Generators - despite being reasonable for true random numbers.While the meaningful notion of "random number" exists (kind of) - there is no such thing as "pseudo-random number". A Pseudo-Random Number Generator actually produces pseudo-random number

sequence.Pseudo-random sequence is in fact always

deterministic(predetermined by its algorithm and initial parameters) - i.e. there is actually nothing random about it.When experts talk about quality of PRNG they actually talk about statistical properties of the generated sequence (and its notable sub-sequences). For example if you combine two high quality PRNGs by using them both in turns - you may produce bad resulting sequence - despite them generating good sequences each separately (those two good sequences may simply correlate to each other and thus combine badly).

Specifically

`rand()`

/`srand(s)`

pair of functions provide a singular per-process non-thread-safe(!) pseudo-random number sequence generated with implementation-defined algorithm. Function`rand()`

produces values in range`[0, RAND_MAX]`

.Quote from C11 standard (ISO/IEC 9899:2011):

Many people reasonably expect that

`rand()`

would produce a sequence of semi-independent uniformly distributed numbers in range`0`

to`RAND_MAX`

. Well it most certainly should (otherwise it's useless) but unfortunately not only standard doesn't require that - there is even explicit disclaimer that states"there is no guarantees as to the quality of the random sequence produced". In some historical cases`rand`

/`srand`

implementation was of very bad quality indeed. Even though in modern implementations it is most likely good enough - but the trust is broken and not easy to recover. Besides its non-thread-safe nature makes its safe usage in multi-threaded applications tricky and limited (still possible - you may just use them from one dedicated thread).New class template std::mersenne_twister_engine<> (and its convenience typedefs -

`std::mt19937`

/`std::mt19937_64`

with good template parameters combination) providesper-objectpseudo-random number generator defined in C++11 standard. With the same template parameters and the same initialization parameters different objects will generate exactly the same per-object output sequence on any computer in any application built with C++11 compliant standard library. The advantage of this class is its predictably high quality output sequence and full consistency across implementations.Also there are more PRNG engines defined in C++11 standard - std::linear_congruential_engine<> (historically used as fair quality

`srand/rand`

algorithm in some C standard library implementations) and std::subtract_with_carry_engine<>. They also generate fully defined parameter-dependent per-object output sequences.Modern day C++11 example replacement for the obsolete C code above:

The version of previous code that uses std::uniform_int_distribution<>