Namespaces
Variants

std::ranges:: generate_random

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
Definiert in Header <random>
Aufrufsignatur
template < class R, class G >

erfordert ranges:: output_range < R, std:: invoke_result_t < G & >> &&
std:: uniform_random_bit_generator < std:: remove_cvref_t < G >>
constexpr ranges:: borrowed_iterator_t < R >

generate_random ( R && r, G && g ) ;
(1) (seit C++26)
template < class G, std:: output_iterator < std:: invoke_result_t < G & >> O,

std:: sentinel_for < O > S >
erfordert std:: uniform_random_bit_generator < std:: remove_cvref_t < G >>
constexpr O

generate_random ( O first, S last, G && g ) ;
(2) (seit C++26)
template < class R, class G, class D >

erfordert ranges:: output_range < R, std:: invoke_result_t < D & , G & >> &&
std:: invocable < D & , G & > &&
std:: uniform_random_bit_generator < std:: remove_cvref_t < G >> &&
std:: is_arithmetic_v < std:: invoke_result_t < D & , G & >>
constexpr ranges:: borrowed_iterator_t < R >

generate_random ( R && r, G && g, D && d ) ;
(3) (seit C++26)
template < class G, class D, std:: output_iterator < std:: invoke_result_t < D & , G & >> O,

std:: sentinel_for < O > S >
erfordert std:: invocable < D & , G & > &&
std:: uniform_random_bit_generator < std:: remove_cvref_t < G >> &&
std:: is_arithmetic_v < std:: invoke_result_t < D & , G & >>
constexpr O

generate_random ( O first, S last, G && g, D && d ) ;
(4) (seit C++26)

Versucht, Zufallszahlen mit der generate_random Memberfunktion des Zufallszahlengenerators oder der Verteilung zu erzeugen, was voraussichtlich effizienter ist. Greift auf elementweise Erzeugung zurück, falls keine generate_random Memberfunktion verfügbar ist.

Lassen Sie den Fallback-Vorgang den Aufruf von ranges:: generate ( std:: forward < R > ( r ) , std:: ref ( g ) ) oder ranges:: generate ( std:: forward < R > ( r ) , [ & d, & g ] { return std:: invoke ( d, g ) ; } ) für (1) oder (3) sein.

1) Ruft g. generate_random ( std:: forward < R > ( r ) ) auf, falls dieser Ausdruck wohlgeformt ist.
Andernfalls sei I gleich std:: invoke_result_t < G & > . Falls R das Konzept sized_range modelliert, füllt r mit ranges:: size ( r ) Werten vom Typ I durch Ausführung einer nicht näher spezifizierten Anzahl von Aufrufen der Form g ( ) oder g. generate_random ( s ) , falls ein solcher Ausdruck wohlgeformt ist für einen Wert N und ein Objekt s vom Typ std:: span < I, N > .
Andernfalls führt es den Fallback-Vorgang aus.
3) Ruft d. generate_random ( std:: forward < R > ( r ) , g ) auf, falls dieser Ausdruck wohlgeformt ist.
Andernfalls sei I gleich std:: invoke_result_t < D & , G & > . Falls R das Konzept sized_range modelliert, füllt r mit ranges:: size ( r ) Werten des Typs I durch Ausführung einer nicht näher spezifizierten Anzahl von Aufrufen der Form std:: invoke ( d, g ) oder d. generate_random ( s, g ) , falls ein solcher Ausdruck für einen Wert N und ein Objekt s vom Typ std:: span < I, N > wohlgeformt ist.
Andernfalls führt es den Fallback-Vorgang aus.
2,4) Entspricht (1,3) jeweils, wobei r aus ranges:: subrange < O, S > ( std :: move ( first ) , last ) erhalten wird.

Wenn die Auswirkungen von (1) oder (3) nicht denen des entsprechenden Fallback-Vorgangs entsprechen, ist das Verhalten undefiniert.

Der Wert von N kann zwischen verschiedenen Aufrufen variieren. Implementierungen können für kürzere Bereiche kleinere Werte wählen.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

Inhaltsverzeichnis

Parameter

first, last - das Iterator-Sentinel-Paar, das den Bereich definiert, in den Zufallszahlen geschrieben werden
r - der range , in den Zufallszahlen geschrieben werden
g - gleichförmiger Zufallsbitgenerator
d - Zufallszahlenverteilungsobjekt

Hinweise

Zum Zeitpunkt der Standardisierung von std::ranges::generate_random gibt es in der Standardbibliothek keinen Zufallszahlengenerator oder keine Verteilung, die eine generate_random -Memberfunktion bereitstellt.

std::ranges::generate_random kann effizienter sein, wenn es mit einem benutzerdefinierten Zufallszahlengenerator verwendet wird, der eine zugrunde liegende vektorisierte API umschließt.

Feature-Test Makro Wert Std Feature
__cpp_lib_ranges_generate_random 202403L (C++26) std::ranges::generate_random

Beispiel

Diesen Code ausführen 
#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');
}

Mögliche Ausgabe: 

16807       282475249   1622650073  984943658 
1144108930  470211272   101027544   1457850878
1458777923  2007237709  823564440   1115438165
1784484492  74243042    114807987   1137522503

Siehe auch

(C++20)
Speichert das Ergebnis einer Funktion in einem Bereich
(Algorithmus-Funktionsobjekt)
(C++20)
Spezifiziert, dass ein Typ als einheitlicher Zufallsbitgenerator qualifiziert
(Konzept)