6

I have two related questions concerning the use of distributions inside classes.

  1. Is there some kind of base distribution in C++ in order to use a distribution as a class member without knowing which distribution it will be? I cannot use templates (see question 2)

    class Foo{
    private:
        // could by any distribution
        std::base_distribution dist_;

};

  2. I have another class Bar that should have a vector of Foo as a private member (std::vector<Foo>). The problem is that if Foo uses templates, then it is not possible to have a vector of different template arguments which is exactly what I want to have. 

    class Bar {
    private:
        std::vector<Foo> foo_;

};

boost::variant doesn't help either because I don't know the type of distributions. So this (for example) is not possible in my case:

class Bar{
    private:
        boost::variant<std::normal_distribution<>, std::uniform_real_distribution<> > dists_;
};
beginneR
  • 3,207
  • 5
  • 30
  • 52
  • If you only need to support one kind of random number engine, a `std::function` may well be sufficient. – T.C. Feb 14 '17 at 00:11

2 Answers2

8

No, there are no base classes shared by all distribution templates. Even if there were, your intended approach wouldn't work anyway because of object slicing.

However, it should be fairly easy to create your own base class, and derive from it.

class base_distribution {};

template<typename ...Args> class normal_distribution :
public base_distribution, public std::normal_distribution<Args...> {};

template<typename ...Args> class uniform_int_distribution :
public base_distribution, public std::inform_int_distribution<Args...> {};

... and so on, for whatever distributions you want to support. You will also probably need to delegate the wrappers' constructors to their real distribution base class, for maximum transparency.

At this point, object slicing becomes a factor, so you can't just shove a base_distribution into a class, as a member, or shove it into a vector, and expect it to work. You'll have to use, at very least a

std::shared_ptr<base_distribution>

as a class member, or a container value. At this point, to wrap this up, define whatever virtual methods you need in your base_distribution class, and implement them in the template subclasses appropriately.

Community
  • 1
  • 1
Sam Varshavchik
  • 114,536
  • 5
  • 94
  • 148
  • You may well be able to use `std::unique_ptr`. – Martin Bonner supports Monica Feb 13 '17 at 12:27
  • @MartinBonner That requires giving the base class a virtual destructor, of course. – T.C. Feb 14 '17 at 00:09
  • It does. I keep forgetting that one of the smart pointers can capture the type of the object at construction time, and then correctly delete it, even if the last pointer is of type Base and the destructor is non-virtual. I'd have to look it up to be sure that it was `shared_ptr` - but a virtual destructor is always the safe solution. – Martin Bonner supports Monica Feb 14 '17 at 06:59
1

To my knowledge, there is no "base distribution class" or generic distribution class, in C++. You do have a RandomNumberDistribution concept, but that's obviously not the same thing.

If you want a quick-and-dirty distribution class (and I do mean dirty), I currently use something like that (.h, .cpp).

As for your second question - you might need to have your templated class inherit from a single non-templated class which you can place in your vector (you'll need to use pointer members though, to avoid data slicing).

einpoklum
  • 118,144
  • 57
  • 340
  • 684