QRandomGenerator Class

成员函数文档

这是一个重载函数。

当参数类型不完全匹配时，该函数可帮助解决重载问题。它们会将较小的类型提升为较大参数的类型，并调用正确的重载。

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

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

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

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

这是一个重载函数。

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

另请参阅 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 quint32 *seedBuffer, qsizetype len)

这是一个重载函数。

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

此构造函数等同于

    std::seed_seq sseq(seedBuffer, seedBuffer + len);
    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()。

int QRandomGenerator::bounded(int highest)

这是一个重载函数。

highest highest 必须为正数。

请注意，此函数不能用于获取 int 的全部 32 位范围内的值。请使用generate() 并将其转换为 int。

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

qint64 QRandomGenerator::bounded(qint64 highest)

这是一个重载函数。

highest highest 必须是正数。

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

另请参见 generate()、generate64() 和generateDouble()。

quint32 QRandomGenerator::bounded(quint32 highest)

这是一个重载函数。

在 0（包含）和highest （不包含）之间的范围内生成一个 32 位随机数。使用 std::uniform_int_distribution参数 0 和highest - 1 也可以得到相同的结果。该类还可用于获取大于 32 位的数值；对于 64 位数值，也可使用 64 位 bounded() 重载函数。

例如，要获取介于 0 和 255（包括 255）之间的数值，可以写入...：

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

当然，也可以通过将generate() 的结果屏蔽到低 8 位来获得相同的值。无论哪种方法都同样有效。

请注意，该函数不能用于获取 quint32 全部 32 位范围内的值。请使用generate() 代替。

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

quint64 QRandomGenerator::bounded(quint64 highest)

这是一个重载函数。

在 0（包含）和highest （不包含）之间的范围内生成一个 64 位随机数。使用 std::uniform_int_distribution<quint64>参数 0 和highest - 1 也可以得到相同的结果。

请注意，此函数不能用于获取quint64 全部 64 位范围内的值。请使用generate64() 代替。

另请参见 generate()、generate64() 和generateDouble()。

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

这是一个重载函数。

在lowest （包含）和highest （不包含）之间的范围内随机生成一个 32 位数，这两个值都可以是负数，但highest 必须大于lowest 。

请注意，该函数不能用于获取 int 全部 32 位范围内的值。请使用generate() 并将其转换为 int。

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

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

这是一个重载函数。

在lowest （包含）和highest （不包含）之间的范围内随机生成一个 64 位数，这两个数都可以是负数，但highest 必须大于lowest 。

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

另请参见 generate()、generate64() 和generateDouble()。

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

这是一个重载函数。

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

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

例如，要获取介于 1000（含）和 2000（不含）之间的数值，可以写道

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

请注意，该函数不能用于获取 quint32 全部 32 位范围内的值。请使用generate() 代替。

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

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

这是一个重载函数。

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

使用 std::uniform_int_distribution<quint64>参数lowest 和\a highest - 1 也可得到相同结果。

请注意，此函数不能用于获取quint64 全部 64 位范围内的值。请使用generate64() 代替。

另请参见 generate()、generate64() 和generateDouble()。

void QRandomGenerator::discard(unsigned long long z)

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

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

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

生成N 32 位或 64 位数量（取决于UInt 类型），并将其存储在buffer 数组中。这是一次获得多个数量的最有效方法，因为它减少了调用随机数生成器源的次数。

例如，要填充生成两个 32 位的数量，可以写入"......"：

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

也可以调用generate64() 一次，然后将 64 位数值的两半拆分。

另请参见 generate()。

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

生成count 32 位或 64 位数量（取决于UInt 类型），并将其存储在buffer 指向的缓冲区中。这是一次获得多个数量的最有效方法，因为它减少了调用随机数发生器源的次数。

例如，要在一个包含 16 个条目的列表中填入随机数值，可以写入

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

另请参见 generate().

quint64 QRandomGenerator::generate64()

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

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

quint32 QRandomGenerator::generate()

生成并返回 32 位随机数。

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

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

生成 32 位数量并将其存储在begin 和end 之间的范围内。该函数等同于（并以）：

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

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

请注意，如果 [begin, end) 范围指的是每个元素可存储超过 32 位的区域，则元素仍将仅以 32 位数据初始化。任何其他位都将为零。若要用 64 位数量填充范围，可以写入以下内容：

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

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

另请参见 fillRange()。

double QRandomGenerator::generateDouble()

在标准范围 [0, 1]（即包含 0，不包含 1）内生成一个随机 qreal。

此函数等价于

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

也可以使用 std::uniform_real_distribution参数 0 和 1 也可以得到相同的结果。

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

[static] QRandomGenerator *QRandomGenerator::global()

返回指向共享QRandomGenerator 的指针，该共享 已通过securelySeeded() 进行了播种。该函数可用于创建随机数据，而无需为特定用途创建昂贵的安全种子QRandomGenerator 或存储相当大的QRandomGenerator 对象。

例如，下面创建了一个随机 RGB 颜色：

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

对该对象的访问是线程安全的，因此可以在任何没有锁的线程中使用。该对象也可以复制，复制产生的序列将与共享对象产生的序列相同。但需要注意的是，如果有其他线程访问全局对象，这些线程可能会以不可预测的时间间隔获取样本。

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

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

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

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

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

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

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

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

[static] QRandomGenerator QRandomGenerator::securelySeeded()

返回通过QRandomGenerator::system() 安全播种的新QRandomGenerator 对象。该函数将为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 的指针，该指针始终使用操作系统提供的设施生成随机数。至少在以下操作系统中，系统设施被认为是加密安全的：苹果操作系统（达尔文）、BSD、Linux、Windows。其他操作系统可能也是如此。

它们也可能由真正的硬件随机数生成器支持。因此，此函数返回的QRandomGenerator 不应用于批量数据生成。相反，应使用它为QRandomGenerator 或来自 <random> 标头的随机引擎提供种子。

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

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

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

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

生成并返回 32 位随机数。

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