Random numbers in a constructor of an object array

Question

Firstly, sorry if it's a silly question, but I have recently learn how to deal with classes. My problem is that I've created a constructor which gives every data member a random number, with the following syntax:

#include <random>

...

//Constructor
cSystem::cSystem(void)
{
//Range of random numbers
double lower_bound = -100;
double upper_bound = 100;
std::uniform_real_distribution<double> unif(lower_bound,upper_bound);
std::default_random_engine re;

/*Initialization of data members*/
sMass=1.0014;
sPositionX= unif(re);
sPositionY= unif(re);
}

But then, I want to create an array of these "systems" in my main function

int main (void)
{
cSystem systems[numsist]; //numsist is a constant defined to be 1000

//Function that writes its characteristics in a file using a method that returns positions
getPositions(systems);

return 0;
}

But in the file, I just get

-73.6924    -8.26997
-73.6924    -8.26997
-73.6924    -8.26997

I thought that I was going through the constructor for every element of the array, giving it a different random value, but it seems like a single value is given at the beginning and then it is repeated throughout the vector. What can I do to get a constructor that initializes every element in a random way?

Note: I also get the same values everytime I run the program, I suppose that the seed does not change, why is that the case?

Answer 1

You get the same values of sPositionX and sPositionY for each instance of cSystem since you are creating the std::uniform_real_distribution<double> and the std::default_random_engine every time the constructor is called.

You need to create them once and reuse them in the constructor. One way to do that would be to create class scoped static objects.

struct cSystem
{
   ...

   static std::uniform_real_distribution<double> unif;
   static std::default_random_engine re;
};

and just use them in the constructor.

Here's a complete program.

#include <random>
#include <iostream>

struct cSystem
{
   cSystem();

   double sPositionX;
   double sPositionY;
   double sMass;

   static std::uniform_real_distribution<double> unif;
   static std::default_random_engine re;
};

std::uniform_real_distribution<double> cSystem::unif(-100, 100);
std::default_random_engine cSystem::re;

//Constructor
cSystem::cSystem()
{
   /*Initialization of data members*/
   sMass=1.0014;
   sPositionX= unif(re);
   sPositionY= unif(re);
}

void getPositions(cSystem* systems)
{
   for (unsigned i = 0; i < 3; ++i )
   {
      std::cout << systems[i].sPositionX << " " << systems[i].sPositionY << std::endl;
   }
}

int main (void)
{
   cSystem systems[3];

   getPositions(systems);

   return 0;
}

See it working at https://ideone.com/bS8E4u.

Update, in response to OP's comment.

You can initialize re as shown below to get different random numbers when the program is run again and again.

std::default_random_engine cSystem::re{std::random_device()()};

Answer 2

My problem is that I've created a constructor which gives every data member a random number

• You are not seeding the PRNG when you make it default constructed. It will start with its default state every time.
• The PRNG is not supposed to be owned by any one class. It's expensive to seed it, and it is supposed to be shared by all functions (per thread) that needs to generate random numbers - so separate it from any classes.

I perfer to select a certain PRNG, but with the default, it could look like this:

std::default_random_engine& prng() {
    // seed only one PRNG per thread that needs is:
    static thread_local std::default_random_engine gen(std::random_device{}());
    return gen;
}

In every distribution function (member function or otherwise) you use in your program you may now call prng() to get the generator, seeded once and not overseeded.