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
Défini dans l'en-tête <random>
Signature d'appel
template < class R, class G >

requires 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) (depuis C++26)
template < class G, std:: output_iterator < std:: invoke_result_t < G & >> O,

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

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

requires 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) (depuis C++26)
template < class G, class D, std:: output_iterator < std:: invoke_result_t < D & , G & >> O,

std:: sentinel_for < O > S >
requires 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) (depuis C++26)

Tente de générer des nombres aléatoires avec la generate_random fonction membre du générateur de nombres aléatoires ou de la distribution, ce qui est censé être plus efficace. Retourne à la génération élément par élément si aucune generate_random fonction membre n'est disponible.

Soit l'opération de repli l'appel de ranges:: generate ( std:: forward < R > ( r ) , std:: ref ( g ) ) ou ranges:: generate ( std:: forward < R > ( r ) , [ & d, & g ] { return std:: invoke ( d, g ) ; } ) pour (1) ou (3) respectivement.

1) Appelle g. generate_random ( std:: forward < R > ( r ) ) si cette expression est bien formée.
Sinon, soit I le type std:: invoke_result_t < G & > . Si R modélise sized_range , remplit r avec ranges:: size ( r ) valeurs de type I en effectuant un nombre non spécifié d'invocations de la forme g ( ) ou g. generate_random ( s ) , si une telle expression est bien formée pour une valeur N et un objet s de type std:: span < I, N > .
Sinon, effectue l'opération de repli.
3) Appelle d. generate_random ( std:: forward < R > ( r ) , g ) si cette expression est bien formée.
Sinon, soit I le type std:: invoke_result_t < D & , G & > . Si R modélise sized_range , remplit r avec ranges:: size ( r ) valeurs de type I en effectuant un nombre non spécifié d'invocations de la forme std:: invoke ( d, g ) ou d. generate_random ( s, g ) , si une telle expression est bien formée pour une valeur N et un objet s de type std:: span < I, N > .
Sinon, effectue l'opération de repli.
2,4) Équivalent à (1,3) respectivement, où r est obtenu à partir de ranges:: subrange < O, S > ( std :: move ( first ) , last ) .

Si les effets de (1) ou (3) ne sont pas équivalents à ceux de l'opération de repli correspondante, le comportement est indéfini.

La valeur de N peut varier entre les invocations. Les implémentations peuvent choisir des valeurs plus petites pour des plages plus courtes.

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithmes (informellement appelés niebloids ), c'est-à-dire :

Table des matières

Paramètres

first, last - la paire itérateur-sentinelle définissant la plage d'éléments à laquelle les nombres aléatoires sont écrits
r - la range à laquelle les nombres aléatoires sont écrits
g - générateur uniforme de bits aléatoires
d - objet de distribution de nombres aléatoires

Notes

Au moment de la standardisation de std::ranges::generate_random , il n'existe aucun générateur de nombres aléatoires ou distribution dans la bibliothèque standard qui fournisse une fonction membre generate_random .

std::ranges::generate_random peut être plus efficace lorsqu'il est utilisé avec un générateur de nombres aléatoires défini par l'utilisateur qui encapsule une API vectorisée sous-jacente.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_ranges_generate_random 202403L (C++26) std::ranges::generate_random

Exemple

Exécuter ce code 
#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');
}

Sortie possible : 

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

Voir aussi

(C++20)
enregistre le résultat d'une fonction dans une plage
(objet fonction algorithme)
(C++20)
spécifie qu'un type est qualifié comme générateur uniforme de bits aléatoires
(concept)