QRandomGenerator Class

Documentation sur les fonctions membres

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

Initialise cet objet QRandomGenerator avec la valeur seedValue en tant que graine. Deux objets construits ou réensemencés avec la même valeur de semence produiront la même séquence de nombres.

Voir aussi seed() et securelySeeded().

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

Initialise cet objet QRandomGenerator avec les valeurs trouvées dans le tableau seedBuffer en tant que graine. Deux objets construits ou réensemencés avec la même valeur de semence produiront la même séquence de nombres.

Voir aussi seed() et securelySeeded().

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

Initialise cet objet QRandomGenerator avec la séquence de semences sseq comme semence. Deux objets construits ou réensemencés avec la même valeur de semence produiront la même séquence de nombres.

Voir aussi seed() et securelySeeded().

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

Initialise cet objet QRandomGenerator avec les valeurs trouvées dans l'intervalle de begin à end en tant que graine. Deux objets construits ou réensemencés avec la même valeur de semence produiront la même séquence de nombres.

Ce constructeur est équivalent à :

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

Voir aussi seed() et securelySeeded().

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

Initialise cet objet QRandomGenerator avec les valeurs len trouvées dans le tableau seedBuffer en tant que graine. Deux objets construits ou réensemencés avec la même valeur de semence produiront la même séquence de nombres.

Ce constructeur est équivalent à :

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

Voir aussi 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 QRandomGenerator::system() ou une copie de celui-ci, cet objet lira également les installations 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 que l'objet other dans la séquence déterministe. Les deux objets généreront la même séquence à partir de ce point.

C'est pourquoi il n'est pas conseillé 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 qui ne partage aucune relation avec QRandomGenerator::global().

double QRandomGenerator::bounded(double highest)

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

    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 aussi generateDouble() et bounded(quint64).

int QRandomGenerator::bounded(int highest)

Génère une quantité aléatoire de 32 bits comprise entre 0 (inclus) et highest (exclusif). highest doit être positif.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans la plage complète de 32 bits de int. Il convient plutôt d'utiliser generate() et de le convertir en int.

Voir aussi generate(), generate64() et generateDouble().

qint64 QRandomGenerator::bounded(qint64 highest)

Génère une quantité aléatoire de 64 bits comprise entre 0 (inclus) et highest (exclusif). highest doit être positif.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans l'ensemble de la plage de 64 bits de qint64. Il convient plutôt d'utiliser generate64() et de le convertir en qint64 ou d'utiliser la version non signée de cette fonction.

Voir aussi generate(), generate64() et generateDouble().

quint32 QRandomGenerator::bounded(quint32 highest)

Génère une quantité aléatoire de 32 bits comprise entre 0 (inclus) et highest (exclusif). Le même résultat peut être obtenu en utilisant std::uniform_int_distribution avec les paramètres 0 et highest - 1. Cette classe peut également être utilisée pour obtenir des quantités supérieures à 32 bits ; pour 64 bits, la surcharge bounded() 64 bits peut également être utilisée.

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

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

Naturellement, on peut aussi obtenir la même chose en masquant le résultat de generate() sur les seuls 8 bits inférieurs. 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 la plage complète de 32 bits de quint32. Utilisez plutôt generate().

Voir aussi generate(), generate64() et generateDouble().

quint64 QRandomGenerator::bounded(quint64 highest)

Génère une quantité aléatoire de 64 bits comprise entre 0 (inclus) et highest (exclusif). Le même résultat peut être obtenu 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 la plage complète de 64 bits de quint64. Utilisez plutôt generate64().

Voir aussi generate(), generate64() et generateDouble().

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

Génère une quantité aléatoire de 32 bits comprise entre lowest (inclus) et highest (exclus), les deux pouvant être négatifs, mais highest devant être supérieur à lowest.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans l'ensemble de la plage 32 bits de int. Il convient plutôt d'utiliser generate() et de le convertir en int.

Voir aussi generate(), generate64() et generateDouble().

Cette fonction existe pour aider à la résolution des surcharges lorsque les types des paramètres ne correspondent pas exactement. Cette fonction va promouvoir le plus petit type vers le type du plus grand et appeler la surcharge correcte.

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

Génère une quantité aléatoire de 64 bits comprise entre lowest (inclus) et highest (exclus), les deux pouvant être négatifs, mais highest devant être supérieur à lowest.

Notez que cette fonction ne peut pas être utilisée pour obtenir des valeurs dans la plage complète de 64 bits de qint64. Il faut plutôt utiliser generate64() et le convertir en qint64.

Voir aussi generate(), generate64() et generateDouble().

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

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

Le même résultat peut être obtenu 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 quantités supérieures à 32 bits.

Par exemple, pour obtenir une valeur comprise entre 1000 (incl.) et 2000 (excl.), on écrira :

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

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

Voir aussi generate(), generate64() et generateDouble().

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

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

Le même résultat peut être obtenu 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 la plage complète de 64 bits de quint64. Utilisez plutôt generate64().

Voir aussi generate(), generate64() et generateDouble().

void QRandomGenerator::discard(unsigned long long z)

Rejette les entrées z suivantes de la séquence. Cette méthode équivaut à appeler generate() z fois et à rejeter le résultat, comme dans l'exemple suivant :

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

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

Génère N des quantités 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 plus d'une quantité à la fois, car il réduit le nombre d'appels à la source du générateur de nombres aléatoires.

Par exemple, pour remplir deux quantités de 32 bits, on peut écrire :

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

Il aurait également été possible de faire un appel à generate64(), puis de diviser les deux moitiés de la valeur de 64 bits.

Voir également generate().

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

Génère count des quantités de 32 ou 64 bits (selon le type UInt) et les stocke dans le tampon pointé par buffer. C'est la manière la plus efficace d'obtenir plus d'une quantité à la fois, car elle 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 aussi generate().

quint64 QRandomGenerator::generate64()

Génère une quantité aléatoire de 64 bits et la renvoie.

Voir aussi operator()() et generate().

quint32 QRandomGenerator::generate()

Génère une quantité aléatoire de 32 bits et la renvoie.

Voir aussi operator()() et generate64().

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

Génère des quantités de 32 bits et les stocke dans la plage comprise 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::generatequi nécessite des valeurs entières non signées de 32 bits.

Notez que si la plage [begin, end) fait référence à une zone qui peut stocker plus de 32 bits par élément, les éléments seront toujours initialisés avec seulement 32 bits de données. Tous les autres bits seront à zéro. Pour remplir la plage avec des quantités de 64 bits, on peut écrire :

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

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

Voir également fillRange().

double QRandomGenerator::generateDouble()

Génère un qreal aléatoire 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);

La même chose peut être obtenue en utilisant std::uniform_real_distribution avec les paramètres 0 et 1.

Voir aussi generate(), generate64() et bounded().

[static] QRandomGenerator *QRandomGenerator::global()

Renvoie un pointeur vers un objet partagé QRandomGenerator qui a été ensemencé à l'aide de securelySeeded(). Cette fonction devrait être utilisée pour créer des données aléatoires sans avoir à créer un QRandomGenerator sécurisé pour un usage spécifique ou à stocker un objet QRandomGenerator assez volumineux.

Par exemple, l'exemple suivant crée une couleur RVB aléatoire :

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

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

Remarque : cette fonction est à l'épreuve des threads.

Voir également securelySeeded() et system().

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

Renvoie la valeur maximale que QRandomGenerator peut générer. C'est-à-dire std::numeric_limits<result_type>::max().

Voir aussi min().

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

Renvoie la valeur minimale que QRandomGenerator peut générer. C'est-à-dire 0.

Voir aussi max().

[static] QRandomGenerator QRandomGenerator::securelySeeded()

Renvoie un nouvel objet QRandomGenerator qui a été ensemencé de manière sécurisée avec QRandomGenerator::system(). Cette fonction permet d'obtenir la taille de semence idéale pour l'algorithme utilisé par QRandomGenerator et constitue donc la méthode recommandée pour créer un nouvel objet QRandomGenerator qui sera conservé pendant un certain temps.

Étant donné la quantité de données nécessaires pour ensemencer en toute sécurité le moteur déterministe, cette fonction est quelque peu coûteuse et ne devrait pas être utilisée pour des utilisations à court terme de QRandomGenerator (l'utiliser pour générer moins de 2600 octets de données aléatoires est en fait un gaspillage de ressources). Si l'utilisation ne nécessite pas autant de données, envisagez d'utiliser QRandomGenerator::global() et de ne pas stocker un objet QRandomGenerator à la place.

Voir aussi global() et system().

void QRandomGenerator::seed(quint32 seed = 1)

Réensemence cet objet en utilisant la valeur seed comme semence.

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

Réensemence cet objet en utilisant la séquence de semences seed comme semence.

[static] QRandomGenerator *QRandomGenerator::system()

Renvoie un pointeur vers un site partagé QRandomGenerator qui utilise toujours les facilités fournies par le système d'exploitation pour générer des nombres aléatoires. Les facilités du système sont considérées comme étant cryptographiquement sûres sur au moins les systèmes d'exploitation suivants : Apple OSes (Darwin), BSDs, Linux, Windows : Apple OS (Darwin), BSD, Linux, Windows. Cela peut également être le cas pour d'autres systèmes d'exploitation.

Il est également possible qu'ils soient soutenus par un véritable générateur de nombres aléatoires matériel. C'est pourquoi le site QRandomGenerator renvoyé par cette fonction ne doit pas être utilisé pour la génération de données en masse. Utilisez-le plutôt pour amorcer QRandomGenerator ou un moteur aléatoire à partir de l'en-tête <random>.

L'objet retourné par cette fonction est à l'abri des threads et peut être utilisé dans n'importe quel thread sans verrou. Il peut également être copié et les QRandomGenerator qui en résultent auront également accès aux installations du système d'exploitation, mais ils ne généreront pas la même séquence.

Remarque : cette fonction est à l'épreuve des threads.

Voir aussi securelySeeded() et global().

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

Génère une quantité aléatoire de 32 bits et la renvoie.

Voir également generate() et generate64().