将 C++ 随机数分布传递给函数

Question

I have looked for similar questions but haven't found them. I want to generate normally distributed random numbers. I used to code C and some C++98 but am now trying to go back and learn C++11.

I have a function to return a seeded RNG

auto seeded_rng () {
      ....  //do seeding.
     std::default_random_engine Eng(/*seeds*/);
     return Eng;
}

In my main function I bind the RNG to say a gaussian distribution

auto binded = std::bind(std::normal_distribution<double>{0,1.0},seeded_rng);

This function works fine. I can call "binded()" directly in main and it generates the numbers

I want to have a simulation object that needs random numbers to be created. My question related to how to pass in the "RNG_PART" below.

class sim
{
public:
       sim( RNG_PART & rng, int_number_of sims ){ /* Do whatever */}
}

So if in main, I then want to create a simulation object

sim A(binded, 100);

it complains. I tried declaring

sim::sim(std::default_random_engine &rng, int number_of_sims){}

but it is complaining. What type should I use to pass in the "binded" distribution to the constructor? Or am I going about this completely incorrectly. Should I just declare the RNG engine globally? I'd prefer not to do that.

Apologies if this is very basic!

Answer 1

The type of the argument to sim is not matching the type of binded. When you create binded, you avoid the issue by using auto instead of declaring the type, but you're going to need it later. How about the following in class sim instead of trying to figure out the type ahead of time. This also allows you to change the RNG or the random distribution without changing the sim class:

template<typename T>
class sim
{    
public:
    sim(T& rng, int_number_of sims ){ /* Do whatever */}

Note that the template definition must be visible to the place you use it, so you can't put it into a cpp file unless the only code that uses it is in that file. Typically, the template definition is in the same h file as where it was declared.

Then, you'd create sim as:

sim<decltype(binded)> A(binded,100);

the decltype(binded) is a way to tell the sim function template the type of binded.

Since binded can return different types depending upon the chosen random number distribution, obtaining the return type in the sim class template could be done with

using rnd_return_type = typename std::result_of<T()>::type; //in C++11, C++14

or

using rnd_return_type = std::invoke_result_t<T>; //C++17 and later

std::result_of is deprecated in C++17 and will be removed in C++20