std::ranges::generate_random

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 );

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 );

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 );

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 );

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 supposé être plus efficace. Utilise la génération élément par élément en l'absence de fonction membre generate_random disponible.

Soit l'opération de repli (fallback) qui consiste à appeler 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.

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 différer entre les invocations. Les implémentations peuvent sélectionner des valeurs plus petites pour des plages plus courtes.

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

• Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'eux.
• Aucun d'entre eux n'est visible par recherche dépendante des arguments.
• Lorsque l'un d'eux est trouvé par recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

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.

Exemple

#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');
}

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

Voir aussi