QRandomGenerator Class

Documentation des fonctions membres

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

Initialise cet objet `QRandomGenerator` en utilisant la valeur ` seedValue ` comme graine. Deux objets créés ou réinitialisés avec la même valeur de graine produiront la même séquence de nombres.

Voir également seed() et securelySeeded().

template <qsizetype N> QRandomGenerator::QRandomGenerator(const quint32 (&seedBuffer)[N])

Initialise cet objet `QRandomGenerator` en utilisant comme graine les valeurs contenues dans le tableau ` seedBuffer `. Deux objets créés ou réinitialisés avec la même valeur de graine produiront la même suite de nombres.

Voir également seed() et securelySeeded().

[noexcept] QRandomGenerator::QRandomGenerator(std::seed_seq &sseq)

Initialise cet objet QRandomGenerator en utilisant la séquence de départ sseq comme graine. Deux objets créés ou réinitialisés avec la même valeur de graine produiront la même séquence de nombres.

Voir également seed() et securelySeeded().

QRandomGenerator::QRandomGenerator(const quint32 *begin, const quint32 *end)

Initialise cet objet `QRandomGenerator` en utilisant comme graine les valeurs comprises entre begin et end. Deux objets créés ou réinitialisés avec la même valeur de graine produiront la même séquence de nombres.

Ce constructeur est équivalent à :

    std::seed_seq sseq(begin, end);
    QRandomGenerator generator(sseq);

Voir également seed() et securelySeeded().

QRandomGenerator::QRandomGenerator(const quint32 *seedBuffer, qsizetype len)

Initialise cet objet `QRandomGenerator` en utilisant comme graine les valeurs d'len s contenues dans le tableau ` seedBuffer `. Deux objets créés ou réinitialisés avec la même valeur de graine produiront la même séquence de nombres.

Ce constructeur équivaut à :

    std::seed_seq sseq(seedBuffer, seedBuffer + len);
    QRandomGenerator generator(sseq);

Voir également seed() et securelySeeded().

QRandomGenerator::QRandomGenerator(const QRandomGenerator &other)

Crée une copie de l’état du générateur dans l’objet ` other `. Si ` other ` est de type ` QRandomGenerator::system()` ou une copie de celui-ci, cet objet lira également à partir des fonctions de génération aléatoire du système d’exploitation. Dans ce cas, les séquences générées par les deux objets seront différentes.

Dans tous les autres cas, le nouvel objet `QRandomGenerator` commencera à la même position dans la séquence déterministe que l’objet ` other `. Les deux objets généreront alors la même séquence à partir de ce point.

C’est pourquoi il n’est pas recommandé de créer une copie de ` QRandomGenerator::global()`. Si vous avez besoin d’un générateur déterministe exclusif, envisagez plutôt d’utiliser ` securelySeeded()` pour obtenir un nouvel objet n’ayant aucun lien avec ` QRandomGenerator::global()`.

[constexpr noexcept default] QRandomGenerator::~QRandomGenerator()

Supprime l'instance de ` QRandomGenerator`.

double QRandomGenerator::bounded(double highest)

Génère un nombre double aléatoire compris entre 0 (inclus) et highest (exclus). Cette fonction est équivalente à et est implémentée comme suit :

    return generateDouble() * highest;

Si le paramètre highest est négatif, le résultat sera également négatif ; s'il est infini ou NaN, le résultat sera également infini ou NaN (c'est-à-dire non aléatoire).

Voir également generateDouble() et bounded(quint64).

int QRandomGenerator::bounded(int highest)

Génère un nombre aléatoire de 32 bits compris entre 0 (inclus) et highest (exclus). La valeur de ` highest ` doit être positive.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs couvrant toute la plage de 32 bits du type int. Utilisez plutôt la fonction generate() et effectuez une conversion vers le type int.

Voir également generate(), generate64() et generateDouble().

qint64 QRandomGenerator::bounded(qint64 highest)

Génère un nombre aléatoire de 64 bits compris entre 0 (inclus) et highest (exclus). highest doit être positif.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs sur toute la plage de 64 bits de qint64. Utilisez plutôt generate64() et effectuez un transtypage vers qint64, ou utilisez la version non signée de cette fonction.

Voir également generate(), generate64() et generateDouble().

quint32 QRandomGenerator::bounded(quint32 highest)

Génère une valeur aléatoire de 32 bits comprise entre 0 (inclus) et highest (exclus). On peut également obtenir le même résultat en utilisant std::uniform_int_distribution avec les paramètres 0 et highest - 1. Cette classe peut également être utilisée pour obtenir des nombres supérieurs à 32 bits ; pour 64 bits, on peut également utiliser la surcharge de la fonction bounded() à 64 bits.

Par exemple, pour obtenir une valeur comprise entre 0 et 255 (inclus), on écrirait :

    quint32 v = QRandomGenerator::global()->bounded(256);

Bien entendu, on pourrait également obtenir le même résultat en masquant le résultat de ` generate()` pour ne conserver que les 8 bits de poids faible. Les deux solutions sont aussi efficaces l’une que l’autre.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans toute la plage de 32 bits de `quint32`. Utilisez plutôt ` generate()`.

Voir également generate(), generate64() et generateDouble().

quint64 QRandomGenerator::bounded(quint64 highest)

Génère un nombre aléatoire de 64 bits compris entre 0 (inclus) et highest (exclus). On peut également obtenir le même résultat en utilisant std::uniform_int_distribution<quint64> avec les paramètres 0 et highest - 1.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans l'intervalle complet de 64 bits de quint64. Utilisez plutôt generate64().

Voir également generate(), generate64() et generateDouble().

int QRandomGenerator::bounded(int lowest, int highest)

Génère une valeur aléatoire de 32 bits comprise entre lowest (inclus) et highest (exclus), ces deux valeurs pouvant être négatives, mais highest doit être supérieur à lowest.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans toute la plage de 32 bits du type int. Utilisez plutôt generate() et effectuez un transtypage vers int.

Voir également generate(), generate64() et generateDouble().

Cette fonction sert à faciliter la résolution des surcharges lorsque les types des paramètres ne correspondent pas exactement. Elle convertit le type le plus petit en celui du plus grand et appelle la surcharge appropriée.

qint64 QRandomGenerator::bounded(qint64 lowest, qint64 highest)

Génère un nombre aléatoire de 64 bits compris entre lowest (inclus) et highest (exclus), ces deux valeurs pouvant être négatives, mais highest doit être supérieur à lowest.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans toute la plage de 64 bits de qint64. Utilisez plutôt generate64() et effectuez une conversion vers qint64.

Voir également generate(), generate64() et generateDouble().

quint32 QRandomGenerator::bounded(quint32 lowest, quint32 highest)

Génère un nombre aléatoire de 32 bits compris entre lowest (inclus) et highest (exclus). Le paramètre highest doit être supérieur à lowest.

On peut également obtenir le même résultat en utilisant std::uniform_int_distribution avec les paramètres lowest et \a highest - 1. Cette classe peut également être utilisée pour obtenir des nombres supérieurs à 32 bits.

Par exemple, pour obtenir une valeur comprise entre 1 000 (inclus) et 2 000 (exclus), on écrirait :

    quint32 v = QRandomGenerator::global()->bounded(1000, 2000);

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans toute la plage de 32 bits de quint32. Utilisez plutôt generate().

Voir également generate(), generate64() et generateDouble().

quint64 QRandomGenerator::bounded(quint64 lowest, quint64 highest)

Génère un nombre aléatoire de 64 bits compris entre lowest (inclus) et highest (exclus). Le paramètre highest doit être supérieur à lowest.

On peut également obtenir le même résultat en utilisant std::uniform_int_distribution<quint64> avec les paramètres lowest et \a highest - 1.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans toute la plage 64 bits de quint64. Utilisez plutôt generate64().

Voir également generate(), generate64() et generateDouble().

void QRandomGenerator::discard(unsigned long long z)

Supprime les z entrées suivantes de la séquence. Cette méthode revient à appeler generate() z fois et à ignorer le résultat, comme dans :

    while (z--)
        generator.generate();

template < typename UInt, size_t N, QRandomGenerator::IfValidUInt<UInt> = true > void QRandomGenerator::fillRange(UInt (&buffer)[N])

Génère N des nombres de 32 ou 64 bits (selon le type UInt) et les stocke dans le tableau buffer. C’est le moyen le plus efficace d’obtenir plusieurs nombres à la fois, car cela réduit le nombre d’appels à la source du générateur de nombres aléatoires.

Par exemple, pour générer deux valeurs de 32 bits, on peut écrire :

    quint32 array[2];
    QRandomGenerator::global()->fillRange(array);

Il aurait également été possible d’effectuer un seul appel à generate64() puis de diviser la valeur de 64 bits en deux moitiés.

Voir également generate().

template <typename UInt, QRandomGenerator::IfValidUInt<UInt> = true> void QRandomGenerator::fillRange(UInt *buffer, qsizetype count)

Génère des valeurs de 32 ou 64 bits de type « count » (selon le type UInt) et les stocke dans le tampon pointé par buffer. Il s'agit du moyen le plus efficace d'obtenir plusieurs valeurs à la fois, car cela réduit le nombre d'appels à la source du générateur de nombres aléatoires.

Par exemple, pour remplir une liste de 16 entrées avec des valeurs aléatoires, on peut écrire :

    QList<quint32> list;
    list.resize(16);
    QRandomGenerator::global()->fillRange(list.data(), list.size());

Voir également generate().

quint64 QRandomGenerator::generate64()

Génère un nombre aléatoire de 64 bits et le renvoie.

Voir également operator()() et generate().

quint32 QRandomGenerator::generate()

Génère un nombre aléatoire de 32 bits et le renvoie.

Voir également operator()() et generate64().

template <typename ForwardIterator> void QRandomGenerator::generate(ForwardIterator begin, ForwardIterator end)

Génère des quantités sur 32 bits et les stocke dans l'intervalle compris entre begin et end. Cette fonction est équivalente à (et est implémentée comme) :

    std::generate(begin, end, [this]() { return generate(); });

Cette fonction est conforme aux exigences de la fonction std::seed_seq::generate, qui exige des valeurs entières non signées de 32 bits.

Notez que si l'intervalle [début, fin) fait référence à une zone pouvant stocker plus de 32 bits par élément, les éléments seront tout de même initialisés avec seulement 32 bits de données. Tous les autres bits seront à zéro. Pour remplir l’intervalle avec des quantités de 64 bits, on peut écrire :

    std::generate(begin, end, []() { return QRandomGenerator::global()->generate64(); });

Si l'intervalle fait référence à de la mémoire contiguë (telle qu'un tableau ou les données d'un QList), la fonction fillRange() peut également être utilisée.

Voir également ` fillRange()`.

double QRandomGenerator::generateDouble()

Génère une valeur aléatoire de type qreal dans l'intervalle canonique [0, 1) (c'est-à-dire incluant zéro et excluant 1).

Cette fonction est équivalente à :

    QRandomGenerator64 rd;
    return std::generate_canonical<qreal, std::numeric_limits<qreal>::digits>(rd);

On peut également obtenir le même résultat en utilisant std::uniform_real_distribution avec les paramètres 0 et 1.

Voir également generate(), generate64() et bounded().

[static] QRandomGenerator *QRandomGenerator::global()

Renvoie un pointeur vers un objet ` QRandomGenerator ` partagé dont la valeur initiale a été définie à l'aide de la fonction ` securelySeeded()`. Cette fonction doit être utilisée pour générer des données aléatoires sans avoir à créer, ce qui est coûteux en ressources, un objet ` QRandomGenerator ` initialisé de manière sécurisée pour un usage spécifique, ni à stocker l'objet ` QRandomGenerator `, qui est relativement volumineux.

Par exemple, le code suivant génère une couleur RVB aléatoire :

    return QColor::fromRgb(QRandomGenerator::global()->generate());

Les accès à cet objet sont sûrs pour les threads ; il peut donc être utilisé dans n’importe quel thread sans verrouillage. L’objet peut également être copié, et la séquence produite par la copie sera identique à celle produite par l’objet partagé. Notez toutefois que si d’autres threads accèdent à l’objet global, ces threads peuvent obtenir des échantillons à des intervalles imprévisibles.

Remarque : cette fonction est sûre pour les threads.

Voir également securelySeeded() et system().

[static constexpr] QRandomGenerator::result_type QRandomGenerator::max()

Renvoie la valeur maximale que la fonction ` QRandomGenerator ` puisse jamais générer. Autrement dit, ` std::numeric_limits<result_type>::max()`.

Voir également min().

[static constexpr] QRandomGenerator::result_type QRandomGenerator::min()

Renvoie la valeur minimale que la fonction QRandomGenerator puisse jamais générer. À savoir, 0.

Voir également max().

[static] QRandomGenerator QRandomGenerator::securelySeeded()

Renvoie un nouvel objet ` QRandomGenerator ` dont la graine a été générée de manière sécurisée à l’aide de la fonction ` QRandomGenerator::system()`. Cette fonction permet d’obtenir la taille de graine idéale pour l’algorithme utilisé par ` QRandomGenerator ` ; il s’agit donc de la méthode recommandée pour créer un nouvel objet ` QRandomGenerator ` destiné à être conservé pendant un certain temps.

Compte tenu de la quantité de données nécessaire pour initialiser de manière sécurisée le moteur déterministe, cette fonction est relativement coûteuse et ne doit pas être utilisée pour des applications à court terme de QRandomGenerator (l'utiliser pour générer moins de 2 600 octets de données aléatoires revient en effet à gaspiller des ressources). Si l’utilisation ne nécessite pas autant de données, envisagez plutôt d’utiliser ` QRandomGenerator::global()` et de ne pas stocker d’objet ` QRandomGenerator `.

Voir également global() et system().

void QRandomGenerator::seed(quint32 seed = 1)

Réinitialise cet objet en utilisant la valeur seed comme graine.

[noexcept] void QRandomGenerator::seed(std::seed_seq &seed)

Réinitialise cet objet en utilisant la séquence de départ seed comme valeur de départ.

[static] QRandomGenerator *QRandomGenerator::system()

Renvoie un pointeur vers un générateur de nombres aléatoires partagé ( QRandomGenerator ) qui utilise systématiquement les fonctionnalités fournies par le système d’exploitation pour générer des nombres aléatoires. Ces fonctionnalités sont considérées comme cryptographiquement sûres au moins sur les systèmes d’exploitation suivants : les systèmes d’exploitation Apple (Darwin), les BSD, Linux et Windows. Cela peut également être le cas sur d’autres systèmes d’exploitation.

Elles peuvent également s’appuyer sur un véritable générateur de nombres aléatoires matériel. C’est pourquoi l’ QRandomGenerator e renvoyée par cette fonction ne doit pas être utilisée pour la génération de données en masse. Utilisez-la plutôt pour initialiser QRandomGenerator ou un moteur aléatoire issu de l’en-tête <random>.

L'objet renvoyé par cette fonction est sûr pour les threads et peut être utilisé dans n'importe quel thread sans verrouillage. Il peut également être copié ; l'QRandomGenerator qui en résulte accédera également aux fonctionnalités du système d'exploitation, mais ne générera pas la même séquence.

Remarque : cette fonction est sûre pour les threads.

Voir également securelySeeded() et global().

QRandomGenerator::result_type QRandomGenerator::operator()()

Génère un nombre aléatoire de 32 bits et le renvoie.

Voir aussi generate() et generate64().