QRandomGenerator Class

Dokumentation zu den Member-Funktionen

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

Initialisiert dieses QRandomGenerator-Objekt mit dem Wert „ seedValue “ als Startwert. Zwei Objekte, die mit demselben Startwert erstellt oder neu initialisiert wurden, erzeugen dieselbe Zahlenfolge.

Siehe auch „ seed()“ und „ securelySeeded()“.

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

Initialisiert dieses QRandomGenerator-Objekt mit den Werten aus dem Array „ seedBuffer “ als Startwert. Zwei Objekte, die mit demselben Startwert erstellt oder neu initialisiert wurden, erzeugen dieselbe Zahlenfolge.

Siehe auch ` seed()` und ` securelySeeded()`.

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

Initialisiert dieses QRandomGenerator-Objekt mit der Startsequenz „ sseq “ als Startwert. Zwei Objekte, die mit demselben Startwert erstellt oder neu initialisiert werden, erzeugen dieselbe Zahlenfolge.

Siehe auch seed() und securelySeeded().

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

Initialisiert dieses QRandomGenerator-Objekt mit den Werten aus dem Bereich von begin bis end als Startwert. Zwei Objekte, die mit demselben Startwert erstellt oder neu initialisiert wurden, erzeugen dieselbe Zahlenfolge.

Dieser Konstruktor entspricht:

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

Siehe auch seed() und securelySeeded().

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

Initialisiert dieses QRandomGenerator-Objekt mit den Werten „ len “, die im Array „ seedBuffer “ enthalten sind, als Startwert. Zwei Objekte, die mit demselben Startwert erstellt oder neu initialisiert wurden, erzeugen dieselbe Zahlenfolge.

Dieser Konstruktor entspricht:

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

Siehe auch „ seed()“ und „ securelySeeded()“.

QRandomGenerator::QRandomGenerator(const QRandomGenerator &other)

Erstellt eine Kopie des Generatorzustands im Objekt „ other “. Wenn „ other “ auf „ QRandomGenerator::system()“ gesetzt ist oder eine Kopie davon darstellt, liest dieses Objekt ebenfalls aus den Zufallsgeneratoren des Betriebssystems. In diesem Fall unterscheiden sich die von den beiden Objekten erzeugten Sequenzen.

In allen anderen Fällen beginnt das neue „QRandomGenerator“-Objekt an derselben Position in der deterministischen Sequenz wie das „ other “-Objekt. Beide Objekte erzeugen ab diesem Punkt dieselbe Sequenz.

Aus diesem Grund ist es nicht ratsam, eine Kopie von ` QRandomGenerator::global()` zu erstellen. Wenn Sie einen exklusiven deterministischen Generator benötigen, sollten Sie stattdessen die Verwendung von ` securelySeeded()` in Betracht ziehen, um ein neues Objekt zu erhalten, das in keiner Beziehung zu ` QRandomGenerator::global()` steht.

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

Löscht die Instanz von „ QRandomGenerator “.

double QRandomGenerator::bounded(double highest)

Erzeugt einen zufälligen Double-Wert im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). Diese Funktion entspricht folgender Implementierung:

    return generateDouble() * highest;

Ist der Parameter ` highest ` negativ, ist das Ergebnis ebenfalls negativ; ist er unendlich oder NaN, ist das Ergebnis ebenfalls unendlich oder NaN (d. h., nicht zufällig).

Siehe auch ` generateDouble()` und ` bounded` (quint64).

int QRandomGenerator::bounded(int highest)

Erzeugt eine zufällige 32-Bit-Zahl im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). highest muss positiv sein.

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 32-Bit-Bereich von `int` zu erhalten. Verwenden Sie stattdessen ` generate()` und führen Sie eine Typumwandlung nach `int` durch.

Siehe auch generate(), generate64() und generateDouble().

qint64 QRandomGenerator::bounded(qint64 highest)

Erzeugt eine zufällige 64-Bit-Größe im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). highest muss positiv sein.

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 64-Bit-Bereich von qint64 zu erhalten. Verwenden Sie stattdessen generate64() und wandeln Sie den Wert in einen qint64 um oder nutzen Sie die vorzeichenlose Version dieser Funktion.

Siehe auch ` generate()`, ` generate64()` und ` generateDouble()`.

quint32 QRandomGenerator::bounded(quint32 highest)

Erzeugt einen zufälligen 32-Bit-Wert im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). Das gleiche Ergebnis lässt sich auch erzielen, indem man std::uniform_int_distribution mit den Parametern 0 und highest - 1. Diese Klasse kann auch verwendet werden, um Werte zu erhalten, die größer als 32 Bit sind; für 64 Bit kann ebenfalls die 64-Bit-Überladung von `bounded()` verwendet werden.

Um beispielsweise einen Wert zwischen 0 und 255 (einschließlich) zu erhalten, würde man schreiben:

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

Natürlich könnte man dasselbe Ergebnis auch erzielen, indem man das Ergebnis von ` generate()` auf die unteren 8 Bits maskiert. Beide Lösungen sind gleich effizient.

Beachte, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 32-Bit-Bereich von `quint32` zu erhalten. Verwende stattdessen ` generate()`.

Siehe auch „ generate()“, „ generate64()“ und „ generateDouble()“.

quint64 QRandomGenerator::bounded(quint64 highest)

Erzeugt eine zufällige 64-Bit-Größe im Bereich zwischen 0 (einschließlich) und highest (ausgeschlossen). Das gleiche Ergebnis lässt sich auch erzielen, indem man std::uniform_int_distribution<quint64> mit den Parametern 0 und highest - 1.

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 64-Bit-Bereich von quint64 zu erhalten. Verwenden Sie stattdessen generate64().

Siehe auch generate(), generate64() und generateDouble().

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

Erzeugt eine zufällige 32-Bit-Größe im Bereich zwischen lowest (einschließlich) und highest (ausschließlich), wobei beide Werte negativ sein können, highest jedoch größer als lowest sein muss.

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 32-Bit-Bereich von `int` zu erhalten. Verwenden Sie stattdessen ` generate()` und führen Sie eine Typumwandlung nach `int` durch.

Siehe auch generate(), generate64() und generateDouble().

Diese Funktion dient dazu, die Überladungsauflösung zu unterstützen, wenn die Typen der Parameter nicht exakt übereinstimmen. Dabei wird der kleinere Typ auf den Typ des größeren hochgestuft, und die richtige Überladung wird aufgerufen.

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

Erzeugt eine zufällige 64-Bit-Größe im Bereich zwischen lowest (einschließlich) und highest (ausgeschlossen), wobei beide Werte negativ sein können, highest jedoch größer als lowest sein muss.

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 64-Bit-Bereich von qint64 zu erhalten. Verwenden Sie stattdessen generate64() und wandeln Sie den Wert in einen qint64-Typ um.

Siehe auch generate(), generate64() und generateDouble().

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

Erzeugt eine zufällige 32-Bit-Zahl im Bereich zwischen lowest (einschließlich) und highest (ausschließlich). Der Parameter „ highest “ muss größer als lowest sein.

Das gleiche Ergebnis lässt sich auch erzielen, indem man std::uniform_int_distribution mit den Parametern lowest und \a highest - 1. Diese Klasse kann auch verwendet werden, um Werte zu erhalten, die größer als 32 Bit sind.

Um beispielsweise einen Wert zwischen 1000 (einschließlich) und 2000 (ausschließlich) zu erhalten, würde man schreiben:

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

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 32-Bit-Bereich von `quint32` zu erhalten. Verwenden Sie stattdessen ` generate()`.

Siehe auch ` generate()`, ` generate64()` und ` generateDouble()`.

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

Erzeugt eine zufällige 64-Bit-Zahl im Bereich zwischen lowest (einschließlich) und highest (ausschließlich). Der Parameter „ highest “ muss größer als lowest sein.

Das gleiche Ergebnis lässt sich auch erzielen, indem man std::uniform_int_distribution<quint64> mit den Parametern lowest und \a highest - 1.

Beachten Sie, dass diese Funktion nicht verwendet werden kann, um Werte im gesamten 64-Bit-Bereich von ` quint64` zu erhalten. Verwenden Sie stattdessen ` generate64()`.

Siehe auch generate(), generate64() und generateDouble().

void QRandomGenerator::discard(unsigned long long z)

Verwirft die nächsten z Einträge aus der Sequenz. Diese Methode entspricht dem z -maligen Aufruf von ` generate()` und dem Verwerfen des Ergebnisses, wie im folgenden Beispiel:

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

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

Erzeugt N 32-Bit- oder 64-Bit-Werte (je nach Typ UInt) und speichert diese im Array „ buffer “. Dies ist die effizienteste Methode, um mehrere Werte gleichzeitig zu erhalten, da dadurch die Anzahl der Aufrufe der Zufallszahlengenerator-Quelle reduziert wird.

Um beispielsweise zwei 32-Bit-Werte zu generieren, könnte man schreiben:

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

Es wäre auch möglich gewesen, einen einzigen Aufruf von ` generate64()` durchzuführen und anschließend die beiden Hälften des 64-Bit-Werts aufzuteilen.

Siehe auch ` generate()`.

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

Erzeugt count 32- oder 64-Bit-Werte (abhängig vom Typ UInt) und speichert diese im Puffer, auf den buffer verweist. Dies ist die effizienteste Methode, um mehrere Werte gleichzeitig zu erhalten, da dadurch die Anzahl der Aufrufe des Zufallszahlengenerators reduziert wird.

Um beispielsweise eine Liste mit 16 Einträgen mit Zufallswerten zu füllen, könnte man Folgendes schreiben:

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

Siehe auch generate().

quint64 QRandomGenerator::generate64()

Erzeugt eine 64-Bit-Zufallszahl und gibt diese zurück.

Siehe auch operator()() und generate().

quint32 QRandomGenerator::generate()

Erzeugt eine 32-Bit-Zufallszahl und gibt diese zurück.

Siehe auch operator()() und generate64().

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

Erzeugt 32-Bit-Größen und speichert diese im Bereich zwischen begin und end. Diese Funktion entspricht (und ist implementiert als):

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

Diese Funktion erfüllt die Anforderungen an die Funktion std::seed_seq::generate, die vorzeichenlose 32-Bit-Ganzzahlwerte erfordert.

Beachten Sie: Wenn sich der Bereich [begin, end) auf einen Speicherbereich bezieht, der mehr als 32 Bit pro Element speichern kann, werden die Elemente dennoch nur mit 32 Bit Daten initialisiert. Alle übrigen Bits sind Null. Um den Bereich mit 64-Bit-Größen zu füllen, kann man schreiben:

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

Bezieht sich der Bereich auf zusammenhängenden Speicher (z. B. ein Array oder die Daten aus einem ` QList`), kann auch die Funktion ` fillRange()` verwendet werden.

Siehe auch ` fillRange()`.

double QRandomGenerator::generateDouble()

Erzeugt einen Zufallswert vom Typ `qreal` im kanonischen Bereich [0, 1) (d. h. einschließlich 0 und ausschließlich 1).

Diese Funktion entspricht:

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

Das gleiche Ergebnis lässt sich auch erzielen, indem man std::uniform_real_distribution mit den Parametern 0 und 1.

Siehe auch generate(), generate64() und bounded().

[static] QRandomGenerator *QRandomGenerator::global()

Gibt einen Zeiger auf einen gemeinsam genutzten „ QRandomGenerator “ zurück, der mit „ securelySeeded()“ initialisiert wurde. Diese Funktion sollte verwendet werden, um Zufallsdaten zu erzeugen, ohne dass ein sicher initialisierter „ QRandomGenerator “ für einen bestimmten Zweck erstellt werden muss oder das relativ große „ QRandomGenerator “-Objekt gespeichert werden muss.

Beispielsweise erzeugt der folgende Code eine zufällige RGB-Farbe:

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

Zugriffe auf dieses Objekt sind threadsicher und es kann daher in jedem Thread ohne Sperren verwendet werden. Das Objekt kann auch kopiert werden, wobei die durch die Kopie erzeugte Sequenz mit der des gemeinsam genutzten Objekts übereinstimmt. Beachten Sie jedoch, dass andere Threads, die auf das globale Objekt zugreifen, möglicherweise in unvorhersehbaren Intervallen Stichproben erhalten.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch securelySeeded() und system().

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

Gibt den Maximalwert zurück, den „ QRandomGenerator “ jemals erzeugen kann. Das heißt: „ std::numeric_limits<result_type>::max() “.

Siehe auch min().

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

Gibt den Minimalwert zurück, den „ QRandomGenerator “ jemals generieren kann. Das heißt: 0.

Siehe auch max().

[static] QRandomGenerator QRandomGenerator::securelySeeded()

Gibt ein neues ` QRandomGenerator `-Objekt zurück, das mit ` QRandomGenerator::system()` sicher initialisiert wurde. Diese Funktion ermittelt die ideale Startwertgröße für den von ` QRandomGenerator ` verwendeten Algorithmus und ist daher die empfohlene Methode zum Erstellen eines neuen ` QRandomGenerator `-Objekts, das für einen längeren Zeitraum beibehalten werden soll.

Angesichts der Datenmenge, die für die sichere Initialisierung der deterministischen Engine erforderlich ist, ist diese Funktion relativ ressourcenintensiv und sollte nicht für kurzfristige Anwendungen von QRandomGenerator verwendet werden (die Verwendung zur Erzeugung von weniger als 2600 Byte Zufallsdaten stellt praktisch eine Verschwendung von Ressourcen dar). Wenn für die Anwendung nicht so viele Daten benötigt werden, sollten Sie stattdessen die Verwendung von ` QRandomGenerator::global()` in Betracht ziehen und kein ` QRandomGenerator `-Objekt speichern.

Siehe auch global() und system().

void QRandomGenerator::seed(quint32 seed = 1)

Setzt den Startwert dieses Objekts auf den Wert „ seed “ zurück.

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

Setzt dieses Objekt unter Verwendung der Startwertfolge „ seed “ als Startwert zurück.

[static] QRandomGenerator *QRandomGenerator::system()

Gibt einen Zeiger auf einen gemeinsam genutzten Zufallsgenerator ( QRandomGenerator ) zurück, der stets die vom Betriebssystem bereitgestellten Funktionen zur Erzeugung von Zufallszahlen nutzt. Die Systemfunktionen gelten zumindest auf den folgenden Betriebssystemen als kryptografisch sicher: Apple-Betriebssysteme (Darwin), BSDs, Linux, Windows. Dies kann auch auf anderen Betriebssystemen der Fall sein.

Möglicherweise werden sie zudem von einem echten Hardware-Zufallszahlengenerator unterstützt. Aus diesem Grund sollte das von dieser Funktion zurückgegebene ` QRandomGenerator ` nicht zur Generierung großer Datenmengen verwendet werden. Verwenden Sie es stattdessen, um ` QRandomGenerator ` oder eine Zufallszahlengenerator-Engine aus dem <random>-Header zu initialisieren.

Das von dieser Funktion zurückgegebene Objekt ist threadsicher und kann in jedem Thread ohne Sperren verwendet werden. Es kann auch kopiert werden, und die resultierenden „ QRandomGenerator “ greifen ebenfalls auf die Funktionen des Betriebssystems zu, erzeugen jedoch nicht dieselbe Sequenz.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch securelySeeded() und global().

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

Erzeugt eine 32-Bit-Zufallszahl und gibt diese zurück.

Siehe auch generate() und generate64().