En esta página

QRandomGenerator Class

La clase QRandomGenerator permite obtener valores aleatorios a partir de un generador de números aleatorios de alta calidad. Más información...

Encabezado: #include <QRandomGenerator>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Heredado por:

QRandomGenerator64

Nota: Todas las funciones de esta clase son reentrantes.

Nota: Estas funciones también son seguras para subprocesos:

Tipos públicos

Funciones públicas

QRandomGenerator(quint32 seedValue = 1)
QRandomGenerator(const quint32 (&seedBuffer)[N])
QRandomGenerator(std::seed_seq &sseq)
QRandomGenerator(const quint32 *begin, const quint32 *end)
QRandomGenerator(const quint32 *seedBuffer, qsizetype len)
QRandomGenerator(const QRandomGenerator &other)
~QRandomGenerator()
double bounded(double highest)
int bounded(int highest)
qint64 bounded(qint64 highest)
quint32 bounded(quint32 highest)
quint64 bounded(quint64 highest)
int bounded(int lowest, int highest)
qint64 bounded(int lowest, qint64 highest)
qint64 bounded(qint64 lowest, int highest)
qint64 bounded(qint64 lowest, qint64 highest)
quint32 bounded(quint32 lowest, quint32 highest)
quint64 bounded(quint64 lowest, quint64 highest)
quint64 bounded(quint64 lowest, unsigned int highest)
quint64 bounded(unsigned int lowest, quint64 highest)
void discard(unsigned long long z)
void fillRange(UInt (&buffer)[N])
void fillRange(UInt *buffer, qsizetype count)
quint64 generate64()
quint32 generate()
void generate(ForwardIterator begin, ForwardIterator end)
double generateDouble()
void seed(quint32 seed = 1)
void seed(std::seed_seq &seed)
QRandomGenerator::result_type operator()()

Miembros públicos estáticos

QRandomGenerator *global()
QRandomGenerator::result_type max()
QRandomGenerator::result_type min()
QRandomGenerator securelySeeded()
QRandomGenerator *system()
bool operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2)

Descripción detallada

QRandomGenerator puede utilizarse para generar valores aleatorios a partir de un generador de números aleatorios de alta calidad. Al igual que los motores aleatorios de C++, QRandomGenerator puede inicializarse con valores proporcionados por el usuario a través del constructor. Cuando se le asigna una semilla, la secuencia de números generada por esta clase es determinista. Es decir, con los mismos datos de semilla, QRandomGenerator generará la misma secuencia de números. Sin embargo, con semillas diferentes, los resultados deberían ser considerablemente distintos.

QRandomGenerator::securelySeededSe puede utilizar () para crear un QRandomGenerator inicializado de forma segura con QRandomGenerator::system(), lo que significa que la secuencia de números que genera no se puede predecir fácilmente. Además, ` QRandomGenerator::global()` devuelve una instancia global de `QRandomGenerator` que Qt se asegurará de que esté inicializada de forma segura. Este objeto es seguro para subprocesos, puede compartirse para la mayoría de los usos y siempre se inicializa a partir de ` QRandomGenerator::system()`

QRandomGenerator::system() puede utilizarse para acceder al generador aleatorio criptográficamente seguro del sistema. En sistemas Unix, equivale a leer desde /dev/urandom o a las llamadas al sistema getrandom() o getentropy().

La clase puede generar valores de 32 o 64 bits, o rellenar una matriz con dichos valores. La forma más habitual de generar nuevos valores es llamar a las funciones generate(), generate64() o fillRange(). Se utilizaría de la siguiente manera:

    quint32 value = QRandomGenerator::global()->generate();

Además, proporciona una función de punto flotante generateDouble() que devuelve un número en el intervalo [0, 1) (es decir, incluyendo el cero y excluyendo el 1). También hay un conjunto de funciones de conveniencia que facilitan la obtención de un número aleatorio en un intervalo entero acotado.

Semilla y determinismo

Se puede inicializar QRandomGenerator con datos de inicialización específicos. Cuando se hace esto, los números generados por el objeto serán siempre los mismos, como en el siguiente ejemplo:

    QRandomGenerator prng1(1234), prng2(1234);
    Q_ASSERT(prng1.generate() == prng2.generate());
    Q_ASSERT(prng1.generate64() == prng2.generate64());

Los datos de inicialización adoptan la forma de una o más palabras de 32 bits. El tamaño ideal de la semilla es aproximadamente igual al tamaño de la propia clase QRandomGenerator. Debido a la mezcla de los datos de inicialización, QRandomGenerator no puede garantizar que semillas distintas produzcan secuencias diferentes.

QRandomGenerator::global(), al igual que todos los generadores creados mediante ` QRandomGenerator::securelySeeded()`, siempre se inicializa a partir de ` QRandomGenerator::system()`, por lo que no es posible hacer que produzca secuencias idénticas.

Datos masivos

Cuando funciona en modo determinístico, QRandomGenerator puede utilizarse para la generación de datos a gran escala. De hecho, se recomienda a las aplicaciones que no necesiten datos criptográficamente seguros o verdaderamente aleatorios que utilicen un QRandomGenerator normal en lugar de QRandomGenerator::system() para sus necesidades de datos aleatorios.

Para facilitar su uso, QRandomGenerator proporciona un objeto global que se puede utilizar fácilmente, como en el siguiente ejemplo:

    int x = QRandomGenerator::global()->generate();
    int y = QRandomGenerator::global()->generate();
    int w = QRandomGenerator::global()->bounded(16384);
    int h = QRandomGenerator::global()->bounded(16384);

Generador de números aleatorios a nivel del sistema

QRandomGenerator::system() puede utilizarse para acceder al generador de números aleatorios a nivel del sistema, que es criptográficamente seguro en todos los sistemas en los que se ejecuta Qt. Esta función utilizará recursos de hardware para generar números aleatorios cuando estén disponibles. En dichos sistemas, esas funciones son auténticos generadores de números aleatorios (RNG). Sin embargo, aunque se trate de auténticos RNG, estas funciones tienen fuentes de entropía finitas y, por lo tanto, pueden no producir ningún resultado si se agota su reserva de entropía.

Si eso ocurre, primero el sistema operativo y luego QRandomGenerator recurrirán a generadores de números pseudoaleatorios de calidad decreciente (siendo el generador de reserva de Qt el más sencillo). Que esos generadores sigan teniendo calidad criptográfica depende de la implementación. Por lo tanto, no se debe utilizar QRandomGenerator::system() para la generación de números aleatorios a alta frecuencia, para evitar que la reserva de entropía se agote. Como regla general, no se debe recurrir a esta clase para generar más de un kilobyte por segundo de datos aleatorios (nota: esto puede variar de un sistema a otro).

Si una aplicación necesita datos de un generador de números aleatorios (RNG) verdadero en grandes cantidades, debería utilizar directamente los recursos del sistema operativo (como /dev/random en Linux) y esperar a que haya entropía disponible. Si la aplicación requiere motores PRNG de calidad criptográfica pero no de aleatoriedad verdadera, se puede seguir utilizando QRandomGenerator::system() (véase la sección siguiente).

Si no se requiere ni un RNG verdadero ni un PRNG criptográficamente seguro (CSPRNG), las aplicaciones deberían utilizar en su lugar motores PRNG como el modo determinístico de QRandomGenerator y los de la biblioteca estándar de C++. Se puede utilizar ` QRandomGenerator::system()` para inicializarlos.

Calidad de reserva

QRandomGenerator::system() utiliza los recursos del sistema operativo para obtener números aleatorios, que intentan recopilar entropía real del entorno circundante para generar números verdaderamente aleatorios. Sin embargo, es posible que el reservorio de entropía se agote, en cuyo caso el sistema operativo recurrirá a un generador pseudoaleatorio durante un tiempo. QRandomGenerator::system() no se bloqueará bajo ninguna circunstancia a la espera de que se recopile más entropía.

Los siguientes sistemas operativos garantizan que los resultados de su API de generación aleatoria serán, como mínimo, de calidad criptográficamente segura, incluso si se agota la reserva de entropía: sistemas operativos de Apple (Darwin), BSD, Linux y Windows. Salvo que se produzca un problema de instalación del sistema (como que el proceso actual no pueda leer ` /dev/urandom `), ` QRandomGenerator::system()` ofrecerá, por lo tanto, las mismas garantías.

En otros sistemas operativos, QRandomGenerator recurrirá a un PRNG con una buena distribución numérica, pero no puede garantizar una inicialización adecuada en todos los casos. Consulte la documentación del sistema operativo para obtener más información.

Se recomienda a las aplicaciones que requieran que QRandomGenerator no recurra a generadores de calidad no criptográfica que consulten la documentación de su sistema operativo o que restrinjan su implementación a uno de los sistemas mencionados anteriormente.

A partir de Qt 6.12, QRandomGenerator muestra una advertencia en stderr la primera vez que recurre a un PRNG inseguro. La función opcional randomgenerator_disable_fallback puede configurarse durante la compilación de Qt para desactivar el recurso a un generador inseguro y, en su lugar, cerrar la aplicación si esta intenta utilizar QRandomGenerator y CSPRNG no está disponible.

Reentrancia y seguridad entre subprocesos

QRandomGenerator es reentrante, lo que significa que varios subprocesos pueden operar con esta clase al mismo tiempo, siempre y cuando lo hagan con objetos diferentes. Si varios subprocesos necesitan compartir una secuencia PRNG, se requiere un bloqueo externo mediante un mutex.

Las excepciones son los objetos devueltos por ` QRandomGenerator::global()` y ` QRandomGenerator::system()`: dichos objetos son seguros para subprocesos y pueden ser utilizados por cualquier subproceso sin necesidad de bloqueo externo. Ten en cuenta que la seguridad para subprocesos no se extiende a la copia de dichos objetos: siempre deben utilizarse por referencia.

Compatibilidad con la biblioteca estándar de C++

QRandomGenerator se basa en los requisitos de los generadores de números aleatorios de la Biblioteca Estándar de C++ y puede utilizarse en casi todos los contextos en los que pueden utilizarse los generadores de la Biblioteca Estándar. Las excepciones a estos requisitos son las siguientes:

  • QRandomGenerator no admite la inicialización a partir de otra clase similar a una secuencia de semillas que no sea la propia std::seed_seq;
  • QRandomGenerator no es comparable (aunque sí copiable) ni se puede transmitir a ` std::ostream ` o desde ` std::istream`.

QRandomGenerator también es compatible con las clases de distribución uniforme std::uniform_int_distribution y std:uniform_real_distribution, así como con la función libre std::generate_canonical. Por ejemplo, se puede utilizar el siguiente código para generar un número de coma flotante en el intervalo [1, 2,5):

    std::uniform_real_distribution<> dist(1, 2.5);
    return dist(*QRandomGenerator::global());

Véase también QRandomGenerator64.

Documentación sobre tipos de miembros

QRandomGenerator::result_type

Una definición de tipo (typedef) para el tipo que devuelve la función operator(). Es decir, quint32.

Véase también operator().

Documentación de funciones miembro

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

Inicializa este objeto QRandomGenerator con el valor seedValue como semilla. Dos objetos creados o reiniciados con el mismo valor de semilla generarán la misma secuencia numérica.

Véase también seed() y securelySeeded().

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

Inicializa este objeto QRandomGenerator con los valores que se encuentran en la matriz seedBuffer como semilla. Dos objetos creados o reiniciados con el mismo valor de semilla generarán la misma secuencia numérica.

Esta es una función sobrecargada.

Véanse también seed() y securelySeeded().

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

Inicializa este objeto QRandomGenerator con la secuencia de inicialización sseq como semilla. Dos objetos creados o reinicializados con el mismo valor de semilla producirán la misma secuencia numérica.

Esta es una función sobrecargada.

Véanse también seed() y securelySeeded().

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

Inicializa este objeto QRandomGenerator con los valores que se encuentran en el intervalo comprendido entre begin y end como semilla. Dos objetos creados o reiniciados con el mismo valor de semilla producirán la misma secuencia numérica.

Este constructor es equivalente a:

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

Se trata de una función sobrecargada.

Véase también seed() y securelySeeded().

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

Inicializa este objeto QRandomGenerator con los valores de « len » que se encuentran en la matriz « seedBuffer » como semilla. Dos objetos creados o reiniciados con el mismo valor de semilla producirán la misma secuencia numérica.

Este constructor es equivalente a:

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

Esta es una función sobrecargada.

Véanse también seed() y securelySeeded().

QRandomGenerator::QRandomGenerator(const QRandomGenerator &other)

Crea una copia del estado del generador en el objeto ` other `. Si ` other ` es ` QRandomGenerator::system()` o una copia de este, este objeto también leerá de los mecanismos de generación aleatoria del sistema operativo. En ese caso, las secuencias generadas por los dos objetos serán diferentes.

En todos los demás casos, el nuevo objeto `QRandomGenerator` comenzará en la misma posición de la secuencia determinista en la que se encontraba el objeto ` other `. A partir de ese momento, ambos objetos generarán la misma secuencia.

Por ese motivo, no es recomendable crear una copia de ` QRandomGenerator::global()` (). Si se necesita un generador determinista exclusivo, se recomienda utilizar en su lugar ` securelySeeded()` para obtener un nuevo objeto que no tenga ninguna relación con ` QRandomGenerator::global()` ().

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

Elimina la instancia de « QRandomGenerator ».

double QRandomGenerator::bounded(double highest)

Genera un número aleatorio de tipo `double` en el intervalo comprendido entre 0 (incluido) y ` highest ` (excluido). Esta función es equivalente a la siguiente y se implementa de la siguiente manera:

    return generateDouble() * highest;

Si el parámetro highest es negativo, el resultado también será negativo; si es infinito o NaN, el resultado también será infinito o NaN (es decir, no aleatorio).

Véase también generateDouble() y bounded(quint64).

int QRandomGenerator::bounded(int highest)

Genera un número aleatorio de 32 bits comprendido entre 0 (incluido) y highest (excluido). highest debe ser un número positivo.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 32 bits del tipo `int`. En su lugar, utiliza ` generate()` y convierte el resultado a `int`.

Esta es una función sobrecargada.

Véanse también generate(), generate64() y generateDouble().

qint64 QRandomGenerator::bounded(qint64 highest)

Genera un número aleatorio de 64 bits comprendido entre 0 (incluido) y highest (excluido). highest debe ser positivo.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 64 bits de qint64. En su lugar, utiliza generate64() y convierte el resultado a qint64, o bien utiliza la versión sin signo de esta función.

Nota: Esta función se implementa como un bucle, que depende del valor aleatorio obtenido. A largo plazo, por término medio debería ejecutarse algo menos de dos veces, pero si el generador aleatorio es defectuoso, esta función puede tardar considerablemente más en ejecutarse.

Se trata de una función sobrecargada.

Véase también generate(), generate64() y generateDouble().

quint32 QRandomGenerator::bounded(quint32 highest)

Genera un valor aleatorio de 32 bits comprendido entre 0 (incluido) y highest (excluido). El mismo resultado también se puede obtener utilizando std::uniform_int_distribution con los parámetros 0 y highest - 1. Esa clase también se puede utilizar para obtener valores de más de 32 bits; para 64 bits, también se puede utilizar la sobrecarga de bounded() de 64 bits.

Por ejemplo, para obtener un valor entre 0 y 255 (ambos inclusive), se escribiría:

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

Naturalmente, lo mismo se podría obtener enmascarando el resultado de ` generate()` para que solo se mantengan los 8 bits menos significativos. Ambas soluciones son igual de eficientes.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 32 bits de `quint32`. En su lugar, utiliza ` generate()`.

Esta es una función sobrecargada.

Véase también generate(), generate64() y generateDouble().

quint64 QRandomGenerator::bounded(quint64 highest)

Genera un número aleatorio de 64 bits comprendido entre 0 (incluido) y highest (excluido). El mismo resultado también se puede obtener utilizando std::uniform_int_distribution<quint64> con los parámetros 0 y highest - 1.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 64 bits de quint64. En su lugar, utiliza generate64().

Nota: Esta función está implementada como un bucle, que depende del valor aleatorio obtenido. A largo plazo, por término medio debería ejecutarse algo menos de dos veces, pero si el generador aleatorio es defectuoso, esta función puede tardar considerablemente más en ejecutarse.

Esta es una función sobrecargada.

Véanse también generate(), generate64() y generateDouble().

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

Genera un valor aleatorio de 32 bits en el intervalo comprendido entre lowest (incluido) y highest (excluido), pudiendo ambos ser negativos, pero highest debe ser mayor que lowest.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 32 bits del tipo `int`. En su lugar, utiliza ` generate()` y realiza la conversión a `int`.

Esta es una función sobrecargada.

Véanse también generate(), generate64() y generateDouble().

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

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

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

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

Esta función sirve para facilitar la resolución de sobrecargas cuando los tipos de los parámetros no coinciden exactamente. Promoverá el tipo más pequeño al tipo del más grande y llamará a la sobrecarga correcta.

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

Genera un número aleatorio de 64 bits comprendido entre lowest (incluido) y highest (excluido), pudiendo ambos valores ser negativos, pero highest debe ser mayor que lowest.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 64 bits de qint64. En su lugar, utiliza generate64() y convierte el resultado a qint64.

Nota: Esta función se implementa como un bucle, que depende del valor aleatorio obtenido. A largo plazo, por término medio debería ejecutarse algo menos de dos veces, pero si el generador aleatorio es defectuoso, esta función puede tardar considerablemente más en ejecutarse.

Se trata de una función sobrecargada.

Véase también generate(), generate64() y generateDouble().

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

Genera un número aleatorio de 32 bits en el intervalo comprendido entre lowest (incluido) y highest (excluido). El parámetro highest debe ser mayor que lowest.

El mismo resultado también se puede obtener utilizando std::uniform_int_distribution con los parámetros lowest y \a highest - 1. Esa clase también se puede utilizar para obtener cantidades mayores de 32 bits.

Por ejemplo, para obtener un valor comprendido entre 1000 (incluido) y 2000 (excluido), se escribiría:

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

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 32 bits de `quint32`. En su lugar, utiliza ` generate()`.

Se trata de una función sobrecargada.

Véanse también generate(), generate64() y generateDouble().

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

Genera un número aleatorio de 64 bits comprendido entre lowest (incluido) y highest (excluido). El parámetro « highest » debe ser mayor que lowest.

El mismo resultado también se puede obtener utilizando std::uniform_int_distribution<quint64> con los parámetros lowest y \a highest - 1.

Ten en cuenta que esta función no se puede utilizar para obtener valores en todo el rango de 64 bits de quint64. En su lugar, utiliza generate64().

Nota: Esta función está implementada como un bucle, que depende del valor aleatorio obtenido. A largo plazo, por término medio, debería ejecutarse poco menos de dos veces, pero si el generador aleatorio es defectuoso, esta función puede tardar considerablemente más en ejecutarse.

Esta es una función sobrecargada.

Véanse también generate(), generate64() y generateDouble().

void QRandomGenerator::discard(unsigned long long z)

Descarta las siguientes entradas z de la secuencia. Este método equivale a llamar a generate() z veces y descartar el resultado, tal y como se muestra a continuación:

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

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

Genera N magnitudes de 32 o 64 bits (dependiendo del tipo UInt) y las almacena en el buffer. Esta es la forma más eficiente de obtener más de una magnitud a la vez, ya que reduce el número de llamadas a la fuente del generador de números aleatorios.

Por ejemplo, para generar dos valores de 32 bits, se podría escribir:

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

También habría sido posible realizar una sola llamada a generate64() y, a continuación, dividir las dos mitades del valor de 64 bits.

Véase también generate().

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

Genera count cantidades de 32 o 64 bits (dependiendo del tipo UInt) y las almacena en el búfer al que apunta buffer. Esta es la forma más eficaz de obtener más de una cantidad a la vez, ya que reduce el número de llamadas al código fuente del generador de números aleatorios.

Por ejemplo, para rellenar una lista de 16 entradas con valores aleatorios, se puede escribir:

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

Véase también generate().

quint64 QRandomGenerator::generate64()

Genera un número aleatorio de 64 bits y lo devuelve.

Véase también operator()() y generate().

quint32 QRandomGenerator::generate()

Genera un número aleatorio de 32 bits y lo devuelve.

Véase también operator()() y generate64().

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

Genera magnitudes de 32 bits y las almacena en el intervalo comprendido entre begin y end. Esta función es equivalente a (y se implementa como):

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

Esta función cumple los requisitos de la función std::seed_seq::generate, que requiere valores enteros sin signo de 32 bits.

Tenga en cuenta que si el rango [begin, end) hace referencia a un área que puede almacenar más de 32 bits por elemento, los elementos se inicializarán de todos modos con solo 32 bits de datos. Cualquier otro bit será cero. Para rellenar el rango con cantidades de 64 bits, se puede escribir:

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

Si el rango hace referencia a memoria contigua (como una matriz o los datos de un ` QList`), también se puede utilizar la función ` fillRange()`.

Véase también ` fillRange()`.

double QRandomGenerator::generateDouble()

Genera un valor qreal aleatorio en el intervalo canónico [0, 1) (es decir, que incluye el cero y excluye el 1).

Esta función es equivalente a:

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

Lo mismo se puede obtener también utilizando std::uniform_real_distribution con los parámetros 0 y 1.

Véanse también generate(), generate64() y bounded().

[static] QRandomGenerator *QRandomGenerator::global()

Devuelve un puntero a un objeto ` QRandomGenerator ` compartido cuya semilla se ha establecido mediante ` securelySeeded()`. Esta función debe utilizarse para generar datos aleatorios sin tener que recurrir a la costosa creación de un objeto ` QRandomGenerator ` con semilla segura para un uso específico, ni a almacenar el objeto ` QRandomGenerator `, que ocupa bastante espacio.

Por ejemplo, el siguiente código crea un color RGB aleatorio:

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

Los accesos a este objeto son seguros para subprocesos y, por lo tanto, puede utilizarse en cualquier subproceso sin bloqueos. El objeto también puede copiarse y la secuencia generada por la copia será la misma que la que generaría el objeto compartido. Sin embargo, hay que tener en cuenta que, si hay otros subprocesos accediendo al objeto global, dichos subprocesos pueden obtener muestras a intervalos impredecibles.

Nota: Esta función es segura para subprocesos.

Véase también securelySeeded() y system().

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

Devuelve el valor máximo que « QRandomGenerator » puede llegar a generar. Es decir, « std::numeric_limits<result_type>::max() ».

Véase también min().

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

Devuelve el valor mínimo que « QRandomGenerator » puede generar en cualquier momento. Es decir, 0.

Véase también max().

[static] QRandomGenerator QRandomGenerator::securelySeeded()

Devuelve un nuevo objeto ` QRandomGenerator ` al que se le ha asignado una semilla de forma segura mediante ` QRandomGenerator::system()`. Esta función obtendrá el tamaño de semilla ideal para el algoritmo que utiliza ` QRandomGenerator ` y, por lo tanto, es la forma recomendada de crear un nuevo objeto ` QRandomGenerator ` que se vaya a conservar durante un tiempo.

Dada la cantidad de datos necesarios para inicializar de forma segura el motor determinístico, esta función resulta algo costosa y no debería utilizarse para usos a corto plazo de QRandomGenerator (utilizarla para generar menos de 2 600 bytes de datos aleatorios supone, en la práctica, un desperdicio de recursos). Si el uso no requiere tantos datos, considera utilizar QRandomGenerator::global() y no almacenar un objeto QRandomGenerator.

Véanse también global() y system().

void QRandomGenerator::seed(quint32 seed = 1)

Reinicia este objeto utilizando el valor « seed » como semilla.

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

Reinicia este objeto utilizando la secuencia de inicialización seed como semilla.

Esta es una función sobrecargada.

[static] QRandomGenerator *QRandomGenerator::system()

Devuelve un puntero a un generador de números aleatorios compartido ( QRandomGenerator ) que siempre utiliza los recursos proporcionados por el sistema operativo para generar números aleatorios. Se considera que los recursos del sistema son criptográficamente seguros, al menos, en los siguientes sistemas operativos: sistemas operativos de Apple (Darwin), BSD, Linux y Windows. Es posible que también sea así en otros sistemas operativos.

Además, es posible que estén respaldados por un auténtico generador de números aleatorios por hardware. Por ese motivo, el objeto ` QRandomGenerator ` devuelto por esta función no debe utilizarse para la generación masiva de datos. En su lugar, utilízalo para inicializar ` QRandomGenerator ` o un motor aleatorio de la cabecera `<random>`.

El objeto devuelto por esta función es seguro para subprocesos y puede utilizarse en cualquier subproceso sin bloqueos. También puede copiarse, y el objeto ` QRandomGenerator ` resultante también accederá a los recursos del sistema operativo, pero no generará la misma secuencia.

Nota: Esta función es segura para subprocesos.

Véase también securelySeeded() y global().

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

Genera un número aleatorio de 32 bits y lo devuelve.

Véase también generate() y generate64().

Elementos no miembros relacionados

bool operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2)

Devuelve « true » si los dos motores rng1 y rng2 se encuentran en estados diferentes o si uno de ellos está leyendo desde los recursos del sistema operativo y el otro no; en caso contrario, devuelve « false ».

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.