Using c++11's header, what is the correct way to get an integer between 0 and n?

Question

I'm just starting to use C++11's <random> header for the first time, but there are still some things that seem a bit mysterious. This question is about the intended, idiomatic, best-practice way to accomplish a very simple task.

Currently, in one part of my code I have something like this:

std::default_random_engine eng {std::random_device{}()};
std::uniform_int_distribution<> random_up_to_A {0, A};
std::uniform_int_distribution<> random_up_to_B {0, B};
std::uniform_int_distribution<> random_up_to_some_other_constant {0, some_other_constant};

and then when I want an integer between 0 and B I call random_up_to_B(eng).

Since this is starting to look a bit silly, I want to implement a function rnd such that rnd(n, eng) returns a random integer between 0 and n.

Something like the following ought to work

template <class URNG>
int rnd(int n, URNG &eng) {
    std::uniform_int_distribution<> dist {0, n};
    return dist(eng);
}

but that involves creating a new distribution object every time, and I get the impression that's not the way you're supposed to do it.

So my question is, what is the intended, best-practice way to accomplish this simple task, using the abstractions provided by the <random> header? I ask because I'm bound to want to do much more complicated things than this later on, and I want to make sure I'm using this system in the right way.

Answer 1

uniform_int_distribution should not be expensive to construct, so creating one every time with new limits should be OK. However, there is a way to use the same object with new limits, but it is cumbersome.

uniform_int_distribution::operator() has an overload that takes a uniform_int_distribution::param_type object which can specify the new limits to be used, but param_type itself is an opaque type, and there's no portable way to construct one except extracting it from an existing uniform_int_distribution instance. For instance, the following function can be used to construct a uniform_int_distribution::param_type.

std::uniform_int_distribution<>::param_type
    make_param_type(int min, int max)
{
    return std::uniform_int_distribution<>(min, max).param();
}

Pass these to operator() and the generated result will be in the specified range.

Live demo

So if you really want to reuse the same uniform_int_distribution, create and save multiple instance of param_type using the function above, and use these when calling operator().

---

The answer above is inaccurate, because the standard does specify that the param_type can be constructed from the same distribution arguments as those used by the corresponding distribution type's constructor. Thanks to @T.C. for pointing this out.

From §26.5.1.6/9 [rand.req.dist]

For each of the constructors of D taking arguments corresponding to parameters of the distribution, P shall have a corresponding constructor subject to the same requirements and taking arguments identical in number, type, and default values. ...

So we don't need to construct the distribution object needlessly only to extract the param_type. Instead the make_param_type function can be modified to

template <typename Distribution, typename... Args>
typename Distribution::param_type make_param_type(Args&&... args)
{
  return typename Distribution::param_type(std::forward<Args>(args)...);
}

which can be used as

make_param_type<std::uniform_int_distribution<>>(0, 10)

Live demo

Answer 2

Answering my own question: by adapting an example found in this document, the following appears to be the correct way to implement a function returning a random integer between 0 and n-1 inclusive:

template<class URNG>
int rnd(int n, URNG &engine) {
    using dist_t = std::uniform_int_distribution<>;
    using param_t = dist_t::param_type;

    static dist_t dist;
    param_t params{0,n-1};

    return dist(engine, params);
}

To make it thread-safe one must avoid the static declaration. One possibility is to make a convenience class along these lines, which is what I'm using in my own code:

template<class URNG>
class Random {
public:        
    Random(): engine(std::random_device{}()) {}
    Random(typename std::result_of<URNG()>::type seed): engine(seed) {}

    int integer(int n) {
        std::uniform_int_distribution<>::param_type params {0, n-1};
        return int_dist(engine, params);
    }

private:
    URNG engine;
    std::uniform_int_distribution<> int_dist;
};

This is instantiated with (for example) Random<std::default_random_engine> rnd, and the random integers can then be obtained with rnd.integer(n). Methods for sampling from other distributions can easily be added to this class.

To repeat what I said in the comments, reusing the distribution object is probably unnecessary for the specific task of uniformly sampling integers, but for other distributions I think this will be more efficient than creating it every time, because there are some algorithms for sampling from some distributions that can save CPU cycles by generating multiple values simultaneously. (In principle even uniform_int_distribution could do this, via SIMD vectorisation.) If you can't increase efficiency by retaining the distribution object then it's hard to imagine why they would have designed the API this way.

Hooray for C++ and its needless complexity! This concludes an afternoon's work accomplishing a simple five-minute task, but at least I have a much better idea what I'm doing now.

Answer 3

The idiomatic way to generate code according to varying parameters is to create distribution objects as needed, per Vary range of uniform_int_distribution:

std::random_device rd;
std::default_random_engine eng{rd()};
int n = std::uniform_int_distribution<>{0, A}(eng);

If you are concerned that performance may be hindered by failing to fully exploit the distribution's internal state, you can use a single distribution and pass it different parameters each time:

std::random_device rd;
std::default_random_engine eng{rd()};
std::uniform_int_distribution<> dist;
int n = dist(eng, decltype(dist)::param_type{0, A});

If this seems complicated, consider that for most purposes you will generate random numbers according to the same distribution with the same parameters (hence the distribution constructor taking parameters); by varying parameters you are already entering into advanced territory.