QRandomGenerator 类

成员函数文档

这是一个重载函数。

此函数存在是为了帮助处理参数类型不精确匹配时的重载解析。它们会将较小的类型提升为较大的类型，并调用正确重载。

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

使用seedValue作为种子值初始化此QRandomGenerator对象。使用相同种子值构建或重新播种的两个对象将生成相同的数字序列。

另请参阅seed()和securelySeeded。

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

这是一个重载函数。

使用数组seedBuffer中找到的值作为种子值初始化此QRandomGenerator对象。使用相同种子值构建或重新播种的两个对象将生成相同的数字序列。

另请参阅seed()和securelySeeded。

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

这是一个重载函数。

使用数组seedBuffer中找到的len个值初始化此QRandomGenerator对象作为种子。使用相同种子值构建或重生成的两个对象将产生相同数字序列。

此构造函数等同于

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

另请参阅seed()和securelySeeded。

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

这是一个重载函数。

使用种子序列sseq初始化此QRandomGenerator对象作为种子。使用相同种子值构建或重生成的两个对象将产生相同数字序列。

另请参阅seed()和securelySeeded。

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

这是一个重载函数。

使用介于begin和end之间的值初始化此QRandomGenerator对象作为种子。使用相同种子值构建或重生成的两个对象将产生相同数字序列。

此构造函数等同于

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

另请参阅seed()和securelySeeded。

QRandomGenerator::QRandomGenerator(const QRandomGenerator &other)

在other对象中创建发电机状态的副本。如果other是QRandomGenerator::system()或其副本，则此对象也将从操作系统的随机生成设施中读取。在这种情况下，两个对象生成的序列将不同。

在其他所有情况下，新的QRandomGenerator对象将开始与other对象相同的确定序列位置。从这一点开始，两个对象将生成相同的序列。

因此，不建议创建QRandomGenerator::global的副本。如果需要专属的确定性生成器，可以考虑改用securelySeeded()来获取与QRandomGenerator::global没有关联的新对象。

double QRandomGenerator::bounded(double highest)

生成一个介于0（包含）和highest（不包含）之间的随机double。此函数等同于并作为

    return generateDouble() * highest;

如果highest参数为负，则结果也将是负的；如果是无穷大或NaN，则结果也将是无穷大或NaN（即非随机）。

另请参阅 generateDouble() 和 bounded()。

quint32 QRandomGenerator::bounded(quint32 highest)

这是一个重载函数。

生成一个介于0（包含）和highest（不包含）之间的随机32位整数。还可以通过使用带参数0和highest - 1的std::uniform_int_distribution来获得相同的结果。此类还可以用于获取大于32位的数量；对于64位，也可以使用64位的bounded()重载。

例如，要获取介于0和255（包含）之间的值，可以编写

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

当然，也可以通过仅屏蔽generate()的结果，只保留最低8位来获得相同的结果。两种解决方案都具有同样的效率。

请注意，此函数不能用于获取 quint32 的完整 32 位范围中的值。相反，请使用 generate。

另请参阅generate，generate64 和 generateDouble。

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

这是一个重载函数。

生成一个介于 lowest（包含）和 highest（不包含）之间的随机 32 位数。参数 highest 必须大于 lowest。

也可以通过使用具有参数 lowest 和 \a highest - 1 的 std::uniform_int_distribution 获取相同的结果。该类还可以用于获取大于 32 位的数量。

例如，为了获取介于 1000（包含）和 2000（不包含）之间的值，可以这样编写

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

请注意，此函数不能用于获取 quint32 的完整 32 位范围中的值。相反，请使用 generate。

另请参阅generate，generate64 和 generateDouble。

int QRandomGenerator::bounded(int highest)

这是一个重载函数。

生成一个介于 0（包含）和 highest（不包含）之间的随机 32 位数。参数 highest 必须是正数。

请注意，此函数不能用于获取 int 的完整 32 位范围中的值。相反，请使用 generate 并将其转换为 int。

另请参阅generate，generate64 和 generateDouble。

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

这是一个重载函数。

生成一个介于 lowest（包含）和 highest（不包含）之间的随机 32 位数，两个参数都可能是负数，但 highest 必须大于 lowest。

请注意，此函数不能用于获取 int 的完整 32 位范围中的值。相反，请使用 generate 并将其转换为 int。

另请参阅generate，generate64 和 generateDouble。

quint64 QRandomGenerator::bounded(quint64 highest)

这是一个重载函数。

生成一个介于 0（包含）和 highest（不包含）之间的随机 64 位数。也可以通过使用具有参数 0 和 highest - 1 的 std::uniform_int_distribution<quint64> 获取相同的结果。

请注意，此函数不能用于获取 quint64 的完整 64 位范围中的值。相反，请使用 generate64。

另请参阅generate，generate64 和 generateDouble。

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

这是一个重载函数。

生成一个介于 lowest（包含）和 highest（不包含）之间的随机 64 位数。参数 highest 必须大于 lowest。

也可以通过使用具有参数 lowest 和 \a highest - 1 的 std::uniform_int_distribution<quint64> 获取相同的结果。

请注意，此函数不能用于获取 quint64 的完整 64 位范围中的值。相反，请使用 generate64。

另请参阅generate，generate64 和 generateDouble。

qint64 QRandomGenerator::bounded(qint64 最高值)

这是一个重载函数。

生成一个介于0（包含）和最高值（不包含）之间的随机64位数值。 最高值必须是正数。

请注意，此函数不能用于获取64位qint64的全范围值。请使用generate64()并将结果转换为qint64，或者使用该函数的无符号版本。

另请参阅generate，generate64 和 generateDouble。

qint64 QRandomGenerator::bounded(qint64 最低值, qint64 最高值)

这是一个重载函数。

生成一个介于最低值（包含）和最高值（不包含）之间的随机64位数值，这两个值都可能为负数，但最高值必须大于最低值。

请注意，此函数不能用于获取64位qint64的全范围值。请使用generate64()并将结果转换为qint64。

另请参阅generate，generate64 和 generateDouble。

void QRandomGenerator::discard(unsigned long long z)

丢弃序列中的下一个z个条目。此方法等同于调用generate() z次并丢弃结果，如下所示

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

template <typename UInt, QRandomGenerator::IfValidUInt<UInt> = true> void QRandomGenerator::fillRange(UInt *缓冲区, qsizetype 计数)

生成计数个32位或64位（根据数据类型UInt）数值，并将它们存储在由缓冲区指向的位置。这是同时获取多个数值的最有效方法，因为它减少了进入随机数生成源调用的次数。

例如，要使用随机值填充具有16个条目的列表，可以编写

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

另请参阅 generate。

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

生成N个32位或64位（根据数据类型UInt）数值，并将它们存储在缓冲区数组中。这是同时获取多个数值的最有效方法，因为它减少了进入随机数生成源调用的次数。

例如，要生成两个32位数值，可以编写

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

也可以通过调用generate64()并分割64位值的两个半部分来完成一个调用。

另请参阅 generate。

quint64 QRandomGenerator::generate64()

生成一个64位随机数值并返回它。

另请参阅 operator()() 和 generate。

quint32 QRandomGenerator::generate()

生成一个32位随机数值并返回它。

另请参阅 operator()() 和 generate64。

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

生成32位整数并存储在begin和end之间的范围内。此函数等同于（也以这种方式实现）

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

该函数符合std::seed_seq::generate函数的要求，该函数需要无符号32位整数值。

注意，如果[i, end)范围指的是可以存储单元素超过32位的空间，元素仍将只使用32位数据初始化。其他位都将为零。要填充范围为64位整数，可以这样写

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

如果该范围指的是连续的内存（如数组或QList中的数据），也可以使用fillRange()函数。

另请参阅fillRange。

double QRandomGenerator::generateDouble()

生成一个在规范范围[0, 1)内的qreal随机数（即，包含0但不包括1）。

此函数等同于

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

也可以通过使用std::uniform_real_distribution并设置参数为0和1来得到同样的结果。

另请参阅generate()、generate64()和bounded()。

[静态] QRandomGenerator *QRandomGenerator::global()

返回一个使用securelySeeded修复过的共享QRandomGenerator指针。这个函数应该用来创建随机数据，而不需要为特定的用途创建一个昂贵的QRandomGenerator或存储一个相当大的QRandomGenerator对象。

例如，以下创建了一个随机的RGB颜色

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

对这个对象的访问是线程安全的，因此可以在任何一个线程中使用它而无需加锁。该对象也可以被复制，复制的顺序将和共享对象产生的顺序相同。但是请注意，如果有其他线程正在访问全局对象，那些线程可能会以不可预测的时间间隔获得样本。

注意：此函数是线程安全的。

另请参阅securelySeeded()和system()。

[静态常量表达式] QRandomGenerator::result_type QRandomGenerator::max()

返回QRandomGenerator可能生成的最大值。即，std::numeric_limits<result_type>::max()。

另请参阅min()和QRandomGenerator64::max()。

[静态常量表达式] QRandomGenerator::result_type QRandomGenerator::min()

返回QRandomGenerator可能生成的最小值。即，0。

另请参阅 max() 和 QRandomGenerator64::min()。

[静态] QRandomGenerator QRandomGenerator::securelySeeded()

返回一个新的 QRandomGenerator 对象，它使用 QRandomGenerator::system()() 加密种子。此函数将获取 QRandomGenerator 所使用的算法的理想种子大小，因此是创建一个将保持一段时间的 QRandomGenerator 对象的推荐方法。

由于需要的安全种子数据量，此函数有点昂贵，并且不应用于 QRandomGenerator 的短期使用（用它生成少于2600字节的随机数据实际上是资源的浪费）。如果不需要那么多数据，请考虑使用 QRandomGenerator::global() 并且不存储 QRandomGenerator 对象。

另请参阅 global() 和 system。

void QRandomGenerator::seed(quint32 seed = 1)

使用值 seed 作为种子重新为该对象设置种子。

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

这是一个重载函数。

使用种子序列 seed 作为种子重新为该对象设置种子。

[static] QRandomGenerator *QRandomGenerator::system()

返回指向一个共享的 QRandomGenerator 的指针，它始终使用操作系统提供的设施来生成随机数。在以下操作系统上，系统设施被认为至少是密码学安全的：Apple OSes (Darwin)、BSDs、Linux、Windows。在其他操作系统上也可能是这种情况。

它们也可能由真正的硬件随机数生成器支持。因此，此函数返回的 QRandomGenerator 不应用于生成大量数据。相反，应将其用于为 QRandomGenerator 或来自 `` 头文件的随机引擎设置种子。

此函数返回的对象是线程安全的，可以在任何线程中使用而无需加锁。它还可以被复制，复制后的 QRandomGenerator 也会访问操作系统设施，但将不会生成相同的序列。

注意：此函数是线程安全的。

另请参阅 securelySeeded() 和 global。

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

生成一个32位随机数值并返回它。

另请参阅 generate() 和 generate64。