A shuffle_order_engine random number engine adaptor
produces the same random numbers
that are produced by some base engine e,
but delivers them in a different sequence.

The state
x
of a shuffle_order_engine engine adaptor object x
consists of
the state e of its base engine e,
an additional value Y of the type delivered by e,
and
an additional sequence V of k values
also of the type delivered by e.

The generation algorithm
yields the last value of Y
produced while advancing e's state as described above.

template<class Engine, size_t k> class shuffle_order_engine { public: // types using result_type = typename Engine::result_type; // engine characteristics static constexpr size_t table_size = k; static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } // constructors and seeding functions shuffle_order_engine(); explicit shuffle_order_engine(const Engine& e); explicit shuffle_order_engine(Engine&& e); explicit shuffle_order_engine(result_type s); template<class Sseq> explicit shuffle_order_engine(Sseq& q); void seed(); void seed(result_type s); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); // property functions const Engine& base() const noexcept { return e; }; private: Engine e; // exposition only result_type V[k]; // exposition only result_type Y; // exposition only };

The textual representation
consists of
the textual representation of e,
followed by
the k values of V,
followed by
the value of Y.

In addition to its behavior
pursuant to subclause [rand.req.adapt],
each constructor
that is not a copy constructor
initializes V[0] and Y,
in that order,
with values returned by successive invocations of e().