Vectors and Indexing in C++

Suppose you want a program that simulates rolling a die. A die has faces numbered 1 through 6, so the program needs a random value that is always in that range, never a 0 and never a 7. This is the central problem this article addresses. A random number generator on its own does not know what range you care about. You need a tool that remembers the range you asked for and returns values only from inside it.

The source frames the goal in terms of a number x that is guaranteed to lie in a given range, such as the closed range from 1 to 10 written $[1,10]$, and that you can obtain through a simple expression rather than through low-level details every time. The usage pattern it aims for looks like this: you create a generator for a specific range, and then calling that generator produces one value from the range.

A random number generator is most useful when you can control what it produces. If a simulation of a die accidentally produced a 9, the simulation would be describing a object that does not exist. Constraining output to a range is what makes random values usable for the purpose you have in mind. The range is part of the contract between the generator and the code that uses its values.

A range-constrained generator is worth contrasting with an unbounded one. An unbounded output can land anywhere the generator is capable of producing, so a program that uses it to fill histogram bins could try to store a count at a position that has no bin at all. The range-constrained version guarantees that every returned value has a place to go, which is why the histogram program later depends on the range being respected.

The source defines Rand_int as a class with a constructor that takes a low bound and a high bound, a function-call operator that returns one random integer per call, and two private members. The class is the tool that turns the one-line usage pattern into a working generator. The source notes that the class definition is expert-level code, but that using it is manageable in the first week of a C++ course, which is the perspective taken here.

The class is split into two parts that each do one job. The default_random_engine, named re, is the source of raw randomness. The uniform_int_distribution, named dist, takes that randomness and shapes it so that every integer in the range is equally likely. A uniform distribution is one in which all outcomes are equally likely, and this is the property the source has in mind when it describes the output as uniform.

Read the diagram as a trace of one call. The caller invokes operator(). Operator() hands the engine to the distribution. The engine supplies randomness, the distribution turns that randomness into an integer inside the stored range, and operator() returns that integer to the caller. Nothing in this path lets the caller reach into the engine or the distribution directly.

A single draw tells you very little about whether a generator is fair. To check the distribution, the source counts many draws. The program creates a generator for the range from 0 through a constant max, makes a vector of size max plus one to hold the counts, and then draws 200 values, adding one to the matching slot each time. The vector works as a histogram: each index stands for a possible value, and each stored number records how often that value appeared.

The counting line ++histogram[rnd()] is the core of the program. The call rnd() produces an index between 0 and max, and the increment records one more occurrence at that index. Because the vector has max plus one slots, every possible index has a place to be counted. This matches the fact that the source uses a histogram vector with max plus one slots to count each value from 0 through max.

After the counting loop, a second loop writes a bar graph. For each index i, it prints the index, a tab, and then one star symbol for each counted occurrence. The source describes a healthy result as a reassuringly boring uniform distribution: the bars come out roughly the same length, with reasonable statistical variation from one value to the next. The bars are not expected to be exactly equal, because 200 draws is a finite sample. A uniform distribution shows roughly similar counts with statistical variation, not exactly identical counts.

When a histogram program misbehaves, the useful question is where the result first stops matching your expectation. The source identifies three places where that can happen: the range given to Rand_int, the size given to the vector, and the loop bounds that control how many draws are made. Checking each one in order narrows the search quickly. The most common subtle failure is the mismatch between the range and the vector size, which is an off-by-one error.