C++ Header file not creating random number

Question

My first attempt at creating a header file. The solution is nonsense and nothing more than practice. It receives two numbers from the main file and is supposed to return a random entry from the vector. When I call it from a loop in the main file, it increments by 3 instead of randomly. (Diagnosed by returning the value of getEntry.) The Randomizer code works correctly if I pull it out of the header file and run it directly as a program.

int RandomNumber::Randomizer(int a, int b){
    std::vector < int > vecArray{};
    int range = (b - a) + 1;

    time_t nTime;
    srand((unsigned)time(&nTime));

    for (int i = a-1; i < b+1; i++) {
        vecArray.push_back(i);
    }

    int getEntry = rand() % range + 1;

    int returnValue = vecArray[getEntry];
    vecArray.clear();

    return returnValue;
}

From what I read, header files should generally not contain function and variable definitions. I suspect Rand, being a function, is the source of the problem.

How, if possible, can I get my header file to create random numbers?

Answer 1

void random(){
    double rangeMin = 1;
    double rangeMax = 10;
    size_t numSamples = 10;

    thread_local std::mt19937 mt(std::random_device{}());
    std::uniform_real_distribution<double> dist(rangeMin, rangeMax);

    for (size_t i = 1; i <= numSamples; ++i) {
        std::cout << dist(mt) << std::endl;
    }
}

This method will give you the opportunity to generate random numbers, between two numbers this method you have to include random

Answer 2

There are many cases where you will optate to engender a desultory number. There are genuinely two functions you will require to ken about arbitrary number generation. The first is rand(), this function will only return a pseudo desultory number. The way to fine-tune this is to first call the srand() function.

Here is an example:

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;
 
int main () {
   int i,j;
 
   
   srand( (unsigned)time( NULL ) );

   for( i = 0; i < 10; i++ ) {
      
      j = rand();
      cout <<" Random Number : " << j << endl;
   }

   return 0;
}

Using srand( (unsigned)time( NULL ) ); Instead of using your own value use NULL for the default setting. You can also go here for more info.

I hope I answered your question! Have a nice day!

Answer 3

Ted Lyngmo gave me the idea that fixed the problem. Using random appears to work correctly in a header file.

I removed/changed the following:

time_t nTime;
srand((unsigned)time(&nTime));
int getEntry = rand() % range + 1;

and replaced them with:

std::random_device rd;
std::mt19937 gen(rd());
int getEntry = gen() % range + 1;

Issue resolved. Thank you everybody for your suggestions and comments!

Answer 4

As an experiment, I remove the vector and focus on the randomizer `srand(T)`, where `T` is the system time `volatile time_t T = time(NULL)`. We then found that system is NOT changed during the program running (execution simply too fast).

The function `rand()` generates a pesudo-random integer using confluent rnadom generator, basically multiply the seed by another larger unsigned integer and truncated to the finite bits of `seed`. The randomizer `srand(T)` is used to initialize the seed using system time, or any number `srand(12345);` . A seed gives a fixed sequence of random number. Without calling `srand(T)`, the seed is determined by the system initial memory gabage. The seed is then changed in every generating `rand()`.

In your code, you issue randomizer `srand(T)` reset the seed to the system time in every run. But the system time didn't changed, Thus, you are reseting the `seed` to a same number.

Run this test.

#include <cstdlib>
#include <iostream>
#include <ctime>
int Randomizer(int a, int b){
    volatile time_t T = time(NULL);
    std::cout << "time = " << T << std::endl;
    srand(T);
    std::cout << "rand() = " << rand() << std::endl;
    return rand();
}
int main()
{
   int n1 = 1, n2 = 8;
   for(int i=0; i<5; ++i)
   {
        std::cout << Randomizer(n1, n2) << std::endl;
   }
}

The seed is reset to the system time, which is not change during execution. Thus It renders the same random number.

$ ./a.exe
time = 1608049336
rand() = 9468
15874
time = 1608049336
rand() = 9468
15874
time = 1608049336
rand() = 9468
15874
time = 1608049336
rand() = 9468
15874
time = 1608049336
rand() = 9468
15874

In order to see the change of system time, we add a pause in the main():

int main()
{
    int n1 = 1, n2 = 8;
    for(int i=0; i<5; ++i)
    {
        std::cout << Randomizer(n1, n2) << std::endl;
        system("pause");
    }
}

We can observe the system time moving on...

$ ./a.exe
time = 1608050805
rand() = 14265
11107
Press any key to continue . . .

time = 1608050809
rand() = 14279
21332
Press any key to continue . . .

time = 1608050815
rand() = 14298
20287
Press any key to continue . . .

Because system time is not much different, the first generation of confluent sequence rand() is also rather closed, but the continue sequence of numbers will be "seemingly" random. The principle for confluent random generator is that once after set the seed don't change it. Until you are working for another series of random set. Therefore, put the srand(T) funtcion just once in the main() or somewhere that executed only once.

int main()
{
    srand(time(NULL)); // >>>> just for this once  <<<< 
    int n1 = 1, n2 = 8;
    for(int i=0; i<5; ++i)
   {
        std::cout << Randomizer(n1, n2) << std::endl;
   }
}