QRandomGenerator Class

Dokumentation der Mitgliedsfunktionen

Dies ist eine überladene Funktion.

Diese Funktion soll bei der Überladungsauflösung helfen, wenn die Typen der Parameter nicht genau übereinstimmen. Der kleinere Typ wird in den Typ des größeren überführt und die richtige Überladung aufgerufen.

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

Initialisiert dieses QRandomGenerator-Objekt mit dem Wert seedValue als Startwert. Zwei Objekte, die mit demselben Seed-Wert erstellt oder neu gesetzt werden, erzeugen dieselbe Zahlenfolge.

Siehe auch seed() und securelySeeded().

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

Dies ist eine überladene Funktion.

Initialisiert dieses QRandomGenerator-Objekt mit den im Array seedBuffer gefundenen Werten als Seed. Zwei Objekte, die mit demselben Seed-Wert erstellt oder neu gesetzt werden, erzeugen dieselbe Zahlenfolge.

Siehe auch seed() und securelySeeded().

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

Dies ist eine überladene Funktion.

Initialisiert dieses QRandomGenerator-Objekt mit der Seed-Sequenz sseq als Seed. Zwei Objekte, die mit demselben Seed-Wert erzeugt oder neu gesetzt wurden, erzeugen dieselbe Zahlenfolge.

Siehe auch seed() und securelySeeded().

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

Dies ist eine überladene Funktion.

Initialisiert dieses QRandomGenerator-Objekt mit den im Bereich von begin bis end gefundenen Werten als Startwert. Zwei Objekte, die mit demselben Seed-Wert konstruiert oder neu initialisiert wurden, werden dieselbe Zahlenfolge erzeugen.

Dieser Konstruktor ist äquivalent zu:

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

Siehe auch seed() und securelySeeded().

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

Dies ist eine überladene Funktion.

Initialisiert dieses QRandomGenerator-Objekt mit den im Array seedBuffer gefundenen Werten len als Seed. Zwei Objekte, die mit demselben Seed-Wert konstruiert oder neu initialisiert wurden, erzeugen dieselbe Zahlenfolge.

Dieser Konstruktor ist äquivalent zu:

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

Siehe auch seed() und securelySeeded().

QRandomGenerator::QRandomGenerator(const QRandomGenerator &other)

Erzeugt eine Kopie des Generatorstatus im Objekt other. Wenn other QRandomGenerator::system () oder eine Kopie davon ist, liest dieses Objekt auch von den Zufallsgeneratoreinrichtungen des Betriebssystems. In diesem Fall werden die von den beiden Objekten erzeugten Sequenzen unterschiedlich sein.

In allen anderen Fällen beginnt das neue QRandomGenerator-Objekt an der gleichen Position in der deterministischen Sequenz wie das other -Objekt. Beide Objekte erzeugen von diesem Punkt an die gleiche Sequenz.

Aus diesem Grund ist es nicht ratsam, eine Kopie von QRandomGenerator::global() zu erstellen. Wenn man einen exklusiven deterministischen Generator benötigt, sollte man stattdessen securelySeeded() verwenden, um ein neues Objekt zu erhalten, das keine Beziehung zu QRandomGenerator::global() hat.

double QRandomGenerator::bounded(double highest)

Erzeugt einen zufälligen Double im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). Diese Funktion ist äquivalent zu und wird implementiert als:

    return generateDouble() * highest;

Wenn der Parameter highest negativ ist, ist auch das Ergebnis negativ; wenn er unendlich oder NaN ist, ist auch das Ergebnis unendlich oder NaN (d.h. nicht zufällig).

Siehe auch generateDouble() und bounded().

int QRandomGenerator::bounded(int highest)

Dies ist eine überladene Funktion.

Erzeugt eine zufällige 32-Bit-Menge 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 wandeln Sie in int um.

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

qint64 QRandomGenerator::bounded(qint64 highest)

Dies ist eine überladene Funktion.

Erzeugt eine zufällige 64-Bit-Menge 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 vollen 64-Bit-Bereich von qint64 zu erhalten. Verwenden Sie stattdessen generate64() und casten Sie nach qint64 oder verwenden Sie stattdessen die vorzeichenlose Version dieser Funktion.

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

quint32 QRandomGenerator::bounded(quint32 highest)

Dies ist eine überladene Funktion.

Erzeugt eine zufällige 32-Bit-Menge im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). Das gleiche Ergebnis erhält man auch durch die Verwendung von std::uniform_int_distribution mit den Parametern 0 und highest - 1. Diese Klasse kann auch verwendet werden, um Mengen zu erhalten, die größer als 32 Bit sind; für 64 Bit kann auch die Überladung 64-bit bounded() verwendet werden.

Um zum Beispiel 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 auch erreichen, indem man das Ergebnis von generate() nur auf die unteren 8 Bits beschränkt. Beide Lösungen sind genauso effizient.

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

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

quint64 QRandomGenerator::bounded(quint64 highest)

Dies ist eine überladene Funktion.

Erzeugt eine zufällige 64-Bit-Menge im Bereich zwischen 0 (einschließlich) und highest (ausschließlich). Das gleiche Ergebnis erhält man auch durch die Verwendung von 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)

Dies ist eine überladene Funktion.

Erzeugt eine zufällige 32-Bit-Menge im Bereich zwischen lowest (einschließlich) und highest (ausschließlich), die beide negativ sein können, aber highest muss größer als lowest 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 wandeln Sie in int um.

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

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

Dies ist eine überladene Funktion.

Erzeugt eine zufällige 64-Bit-Menge im Bereich zwischen lowest (einschließlich) und highest (ausschließlich), die beide negativ sein können, aber highest muss größer als lowest 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 es in qint64 um.

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

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

Dies ist eine überladene Funktion.

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

Das gleiche Ergebnis erhält man auch durch die Verwendung von std::uniform_int_distribution mit den Parametern lowest und \a highest - 1. Diese Klasse kann auch verwendet werden, um Größen zu erhalten, die größer als 32 Bit sind.

Um zum Beispiel einen Wert zwischen 1000 (einschl.) und 2000 (ausschl.) 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 vollen 32-Bit-Bereich von quint32 zu erhalten. Verwenden Sie stattdessen generate().

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

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

Dies ist eine überladene Funktion.

Erzeugt eine 64-Bit-Zufallsmenge im Bereich zwischen lowest (einschließlich) und highest (ausschließlich). Der Parameter highest muss größer als lowest sein.

Das gleiche Ergebnis erhält man auch durch die Verwendung von 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 vollen 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 ist gleichbedeutend mit dem Aufruf von generate() z und dem Verwerfen des Ergebnisses, wie in:

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

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

Erzeugt N 32- oder 64-Bit-Mengen (je nach Typ UInt) und speichert sie im Array buffer. Dies ist der effizienteste Weg, um mehr als eine Menge auf einmal zu erhalten, da es die Anzahl der Aufrufe in der Zufallszahlengeneratorquelle reduziert.

Um zum Beispiel zwei 32-Bit-Mengen zu erzeugen, kann man schreiben:

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

Es wäre auch möglich gewesen, einen Aufruf an generate64() zu machen und dann die beiden Hälften des 64-Bit-Wertes aufzuteilen.

Siehe auch generate().

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

Erzeugt count 32- oder 64-Bit-Mengen (je nach Typ UInt) und speichert sie in dem Puffer, auf den buffer zeigt. Dies ist der effizienteste Weg, um mehr als eine Menge auf einmal zu erhalten, da es die Anzahl der Aufrufe der Zufallszahlengeneratorquelle reduziert.

Um zum Beispiel eine Liste mit 16 Einträgen mit Zufallswerten zu füllen, kann man schreiben:

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

Siehe auch generate().

quint64 QRandomGenerator::generate64()

Erzeugt eine 64-Bit-Zufallsmenge und gibt sie zurück.

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

quint32 QRandomGenerator::generate()

Erzeugt eine 32-Bit-Zufallsmenge und gibt sie zurück.

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

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

Erzeugt 32-Bit-Mengen und speichert sie im Bereich zwischen begin und end. Diese Funktion ist äquivalent zu (und wird implementiert als):

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

Diese Funktion erfüllt die Anforderungen für die Funktion std::seed_seq::generatedie vorzeichenlose 32-Bit-Ganzzahlwerte benötigt.

Beachten Sie, dass, wenn der Bereich [Anfang, Ende] sich auf einen Bereich bezieht, der mehr als 32 Bits pro Element speichern kann, die Elemente trotzdem nur mit 32 Bits an Daten initialisiert werden. Alle anderen Bits sind dann Null. Um den Bereich mit 64-Bit-Mengen zu füllen, kann man schreiben:

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

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

Siehe auch fillRange().

double QRandomGenerator::generateDouble()

Erzeugt einen zufälligen qreal im kanonischen Bereich [0, 1) (d.h. einschließlich Null und ausschließlich 1).

Diese Funktion ist äquivalent zu:

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

Dasselbe erhält man auch durch Verwendung von std::uniform_real_distribution mit den Parametern 0 und 1.

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

[static] QRandomGenerator *QRandomGenerator::global()

Gibt einen Zeiger auf ein gemeinsam genutztes QRandomGenerator zurück, das mit securelySeeded() geimpft wurde. Diese Funktion sollte verwendet werden, um Zufallsdaten zu erzeugen, ohne die teure Erstellung eines sicher geseedeten QRandomGenerator für eine bestimmte Verwendung oder die Speicherung des recht großen QRandomGenerator Objekts.

Im Folgenden wird zum Beispiel eine zufällige RGB-Farbe erzeugt:

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

Die Zugriffe auf dieses Objekt sind thread-sicher und es kann daher in jedem Thread ohne Sperren verwendet werden. Das Objekt kann auch kopiert werden, und die von der Kopie erzeugte Sequenz ist die gleiche wie die, die das gemeinsam genutzte Objekt erzeugt. Beachten Sie jedoch, dass, wenn andere Threads auf das globale Objekt zugreifen, diese Threads in unvorhersehbaren Abständen Stichproben erhalten können.

Hinweis: Diese Funktion ist thread-sicher.

Siehe auch securelySeeded() und system().

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

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

Siehe auch min() und QRandomGenerator64::max().

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

Gibt den Mindestwert zurück, den QRandomGenerator jemals erzeugen kann. Das heißt, 0.

Siehe auch max() und QRandomGenerator64::min().

[static] QRandomGenerator QRandomGenerator::securelySeeded()

Gibt ein neues QRandomGenerator Objekt zurück, das mit QRandomGenerator::system() sicher geimpft wurde. Diese Funktion ermittelt die ideale Seed-Größe für den Algorithmus, den QRandomGenerator verwendet, und ist daher der empfohlene Weg, um ein neues QRandomGenerator -Objekt zu erstellen, das für einige Zeit aufbewahrt wird.

In Anbetracht der Datenmenge, die benötigt wird, um die deterministische Engine sicher zu seeden, ist diese Funktion etwas teuer und sollte nicht für kurzfristige Verwendungen von QRandomGenerator verwendet werden (die Verwendung dieser Funktion, um weniger als 2600 Bytes Zufallsdaten zu erzeugen, ist effektiv eine Verschwendung von Ressourcen). Wenn die Verwendung nicht so viele Daten erfordert, sollten Sie QRandomGenerator::global() verwenden und nicht stattdessen ein QRandomGenerator Objekt speichern.

Siehe auch global() und system().

void QRandomGenerator::seed(quint32 seed = 1)

Setzt dieses Objekt mit dem Wert seed als Seed neu.

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

Dies ist eine überladene Funktion.

Setzt dieses Objekt unter Verwendung der Seed-Sequenz seed als Seed neu.

[static] QRandomGenerator *QRandomGenerator::system()

Gibt einen Zeiger auf eine gemeinsam genutzte QRandomGenerator zurück, die immer die vom Betriebssystem bereitgestellten Möglichkeiten zur Erzeugung von Zufallszahlen verwendet. Die Systemfunktionen gelten zumindest auf den folgenden Betriebssystemen als kryptografisch sicher: Apple OS (Darwin), BSDs, Linux, Windows. Dies kann auch auf anderen Betriebssystemen der Fall sein.

Möglicherweise werden sie auch durch einen echten Hardware-Zufallszahlengenerator unterstützt. Aus diesem Grund sollte die von dieser Funktion zurückgegebene QRandomGenerator nicht für die Erzeugung von Massendaten verwendet werden. Verwenden Sie es stattdessen, um QRandomGenerator oder eine Zufallsmaschine aus dem <random>-Header zu seeden.

Das von dieser Funktion zurückgegebene Objekt ist thread-sicher und kann in jedem Thread ohne Sperren verwendet werden. Es kann auch kopiert werden, und die resultierende QRandomGenerator wird ebenfalls auf die Einrichtungen des Betriebssystems zugreifen, aber sie werden nicht die gleiche Sequenz erzeugen.

Hinweis: Diese Funktion ist thread-sicher.

Siehe auch securelySeeded() und global().

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

Erzeugt eine 32-Bit-Zufallsmenge und gibt sie zurück.

Siehe auch generate() und generate64().