std::ranges::generate_random
Defined in header <random>
|
||
Call signature |
||
template< class R, class G > requires ranges::output_range<R, std::invoke_result_t<G&>> && |
(1) | (since C++26) |
template< class G, std::output_iterator<std::invoke_result_t<G&>> O, std::sentinel_for<O> S > |
(2) | (since C++26) |
template< class R, class G, class D > requires ranges::output_range<R, std::invoke_result_t<D&, G&>> && |
(3) | (since C++26) |
template< class G, class D, std::output_iterator<std::invoke_result_t<D&, G&>> O, std::sentinel_for<O> S > |
(4) | (since C++26) |
Attempts to generate random numbers with the generate_random
member function of the random number generator or the distribution, which is expected to be more efficient. Falls back to element-wise generation if no generate_random
member function is available.
Let fallback operation be calling ranges::generate(std::forward<R>(r), std::ref(g)) or ranges::generate(std::forward<R>(r), [&d, &g] { return std::invoke(d, g); }) for (1) or (3) respectively.
R
models sized_range
, fills r with ranges::size(r) values of I by performing an unspecified number of invocations of the form g() or g.generate_random(s), if such an expression is well-formed for a value N
and an object s of type std::span<I, N>.R
models sized_range
, fills r with ranges::size(r) values of type I by performing an unspecified number of invocations of the form std::invoke(d, g) or d.generate_random(s, g), if such an expression is well-formed for a value N
and an object s of type std::span<I, N>.If the effects of (1) or (3) are not equivalent to those of the corresponding fallback operation, the behavior is undefined.
The value of N
can differ between invocations. Implementations may select smaller values for shorter ranges.
The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:
- Explicit template argument lists cannot be specified when calling any of them.
- None of them are visible to argument-dependent lookup.
- When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.
Contents |
[edit] Parameters
first, last | - | iterator-sentinel pair that denotes the range to which random numbers are written |
r | - | range to which random numbers are written |
g | - | uniform random bit generator |
d | - | random number distribution object |
[edit] Notes
At the time of the standardization of std::ranges::generate_random
, there is no random number generator or distribution in the standard library that provides a generate_random
member function.
std::ranges::generate_random
can be more efficient when used with a user-defined random number generator that wraps an underlying vectorized API.
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_ranges_generate_random |
202403L |
(C++26) | std::ranges::generate_random
|
[edit] Example
#include <algorithm> #include <iomanip> #include <iostream> #include <random> int main() { std::default_random_engine eng; std::default_random_engine::result_type rs[16]{}; std::ranges::generate_random(rs, eng); std::cout << std::left; for (int i{}; auto n : rs) std::cout << std::setw(11) << n << (++i % 4 ? ' ' : '\n'); }
Possible output:
16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709 823564440 1115438165 1784484492 74243042 114807987 1137522503
[edit] See also
(C++20) |
saves the result of a function in a range (algorithm function object) |
(C++20) |
specifies that a type qualifies as a uniform random bit generator (concept) |