<boost/random.hpp>
namespace boost {
template<class UniformRandomNumberGenerator, class IntType = long>
class random_number_generator;
template<class Generator>
class generator_iterator;
} // namespace boost
random_number_generator
template<class UniformRandomNumberGenerator, class IntType = long>
class random_number_generator
{
public:
typedef UniformRandomNumberGenerator base_type;
typedef IntType argument_type;
typedef IntType result_type;
random_number_generator(base_type & rng);
result_type operator()(argument_type n);
};
random_number_generator
model a RandomNumberGenerator (std:25.2.11 [lib.alg.random.shuffle]).
On each invocation, it returns a uniformly distributed integer in
the range [0..n).
The template parameter IntType shall denote some
integer-like value type.
Note: I consider it unfortunate that the C++ Standard uses the name RandomNumberGenerator for something rather specific.
random_number_generator(base_type & rng)Effects: Constructs a
random_number_generator functor with the given uniform
random number generator as the underlying source of random numbers.
result_type operator()(argument_type n)Returns: The value of
uniform_int<base_type>(rng, 0, n-1)().
generator_iterator
template<class Generator>
class generator_iterator
: equality_comparable<generator_iterator<Generator> >,
incrementable<generator_iterator<Generator> >,
dereferenceable<generator_iterator<Generator>,
typename Generator::result_type>
{
public:
typedef typename Generator::result_type value_type;
typedef std::ptrdiff_t difference_type;
typedef const typename Generator::result_type * pointer;
typedef const typename Generator::result_type & reference;
typedef std::input_iterator_tag iterator_category;
explicit generator_iterator(Generator & g);
generator_iterator& operator++();
reference operator*() const;
friend bool operator==(const generator_iterator<Generator>& x,
const generator_iterator<Generator>& y);
};
generator_iterator
satisfy the input iterator requirements (std:24.1.1
[lib.input.iterators]). It allows iterator-like access to a
generator, e.g. a NumberGenerator. Note that all distribution
functions now satisfy the input iterator requirements as-is. However,
the base generators do not.
explicit generator_iterator(Generator & g)Effects: Constructs a
generator_iterator
with g as the underlying generator. Invokes the
underlying generator functor.
generator_iterator& operator++()Effects: Invokes the underlying generator functor.
Returns: *this
reference operator*() constReturns: The value of the last invocation of the underlying generator functor.
bool operator==(const generator_iterator<Generator>& x, const generator_iterator<Generator>& y)Returns:
true if and only if the
x and y have been initialized with a
reference to the same generator functor and *x == *y.
generator_iterator
transforms a generator into an input iterator.
#include <iostream>
#include <boost/random.hpp>
class my_generator
{
public:
typedef int result_type;
my_generator() : state(0) { }
int operator()() { return ++state; }
private:
int state;
};
int main()
{
my_generator gen;
boost::generator_iterator<my_generator> it(gen);
for(int i = 0; i < 10; ++i, ++it)
std::cout << *it << std::endl;
}