在C ++中调用静态成员对象的函数

Question

I'm not sure I've used the right terminology in my title, but here's what I'm trying to do:

I have a lightweight particle class (simplified) that requires random behavior for birth and wall-collision. I'd like to keep the facilities for that in the class itself. To my understanding a static member is created only once and can be shared among all instances of the class.

For the random number generator object, I would like to call the seed method once, but am unsure how to do this, as most examples use plain static variables or functions.

Particle.h:

#include <random>

class Particle
{
    public:
        Particle();
    private:
        static std::default_random_engine pRNG;
        static std::uniform_real_distribution<> dist(0, 1);
};

Particle.cpp

#include "particle.h"
#include <ctime>

std::default_random_engine Particle::pRNG.seed(time(NULL)); // <- wrong, help!

Particle::Particle() {}

// methods, etc.

Putting the seed method into the Particle constructor would call it on every born particle I suppose. The only quick hack I could think of was to add a bool member to the Particle class, that is set to false on the first seed call.

Answer 1

Simple way to do this: Make a class called "AutoInitRNG", which seeds the default_random_engine in its constructor. And make that class a static member variable of Particle. Something like this:

class AutoInitRNG
{
public:
    std::default_random_engine pRNG;

    AutoInitRNG()
    {
        pRNG.seed(time(NULL));
    }
};

class Particle
{
//...
private:
    static AutoInitRNG RNG;
};

Answer 2

std::default_random_engine Particle::pRNG.seed(time(NULL)); // <- wrong, help!

This is perfectly fine, except that its in the wrong place. it should be inside a code block, context of some kind. I suggest to separate this facility to a singleton class, that would be called for random number. Otherwise, you'll have to call it from outside the class somewhere.

Calling it in a constructor will lead to multiple calls, that's not what you want, or if you want to call it from within a class - add a static flag to mark that it has been seeded to make sure you only call it once.

Answer 3

You want to call seed after the construction of Particle::pRNG , and exactly once. Anything with static storage duration is initialized exactly once. And if two definitions with static storage duration and dynamic initialization are in the same translation unit, they'll always be initialized in that order (and destroyed in the reverse order).

So all you need is a second definition. The trick is making up something just so you can define it.

// In header:
class Particle {
    // ...
private:
    static std::default_random_engine pRNG;
    class RNG_Setup_;
    friend class Particle::RNG_Setup_;
};

// In source:
std::default_random_engine Particle::pRNG;
class Particle::RNG_Setup_ {
    RNG_Setup_() { Particle::pRNG.seed(time(nullptr)); }
    static RNG_Setup_ setup_instance;
};
Particle::RNG_Setup_::setup_instance{};