QUuid Class
La clase QUuid almacena un Identificador Único Universal (UUID). Más...
| Cabecera: | #include <QUuid> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Heredado Por: |
Esta clase es fuertemente comparable.
Esta clase es fuertemente comparable con GUID.
Nota: La comparación con GUID es sólo para Windows.
Nota: Todas las funciones de esta clase son reentrantes.
Tipos Públicos
(since 6.6) union | Id128Bytes |
| enum | StringFormat { WithBraces, WithoutBraces, Id128 } |
| enum | Variant { VarUnknown, NCS, DCE, Microsoft, Reserved } |
| enum | Version { VerUnknown, Time, EmbeddedPOSIX, Name, Md5, …, UnixEpoch } |
Funciones Públicas
| QUuid() | |
| QUuid(QAnyStringView text) | |
| QUuid(const GUID &guid) | |
(since 6.6) | QUuid(QUuid::Id128Bytes id128, QSysInfo::Endian order = QSysInfo::BigEndian) |
| QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8) | |
| bool | isNull() const |
| QByteArray | toByteArray(QUuid::StringFormat mode = WithBraces) const |
(since 6.6) QUuid::Id128Bytes | toBytes(QSysInfo::Endian order = QSysInfo::BigEndian) const |
| CFUUIDRef | toCFUUID() const |
| NSUUID * | toNSUUID() const |
| QByteArray | toRfc4122() const |
| QString | toString(QUuid::StringFormat mode = WithBraces) const |
(since 6.6) quint128 | toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const |
| QUuid::Variant | variant() const |
| QUuid::Version | version() const |
| operator GUID() const | |
| QUuid & | operator=(const GUID &guid) |
Miembros públicos estáticos
| QUuid | createUuid() |
| QUuid | createUuidV3(QUuid ns, QByteArrayView baseData) |
| QUuid | createUuidV3(const QUuid &ns, const QString &baseData) |
| QUuid | createUuidV5(QUuid ns, QByteArrayView baseData) |
| QUuid | createUuidV5(const QUuid &ns, const QString &baseData) |
(since 6.9) QUuid | createUuidV7() |
(since 6.6) QUuid | fromBytes(const void *bytes, QSysInfo::Endian order = QSysInfo::BigEndian) |
| QUuid | fromCFUUID(CFUUIDRef uuid) |
| QUuid | fromNSUUID(const NSUUID *uuid) |
| QUuid | fromRfc4122(QByteArrayView bytes) |
| QUuid | fromString(QAnyStringView string) |
(since 6.6) QUuid | fromUInt128(quint128 uuid, QSysInfo::Endian order = QSysInfo::BigEndian) |
No miembros relacionados
| size_t | qHash(const QUuid &key, size_t seed = 0) |
| bool | operator!=(const QUuid &lhs, const GUID &rhs) |
| bool | operator!=(const QUuid &lhs, const QUuid &rhs) |
| bool | operator<(const QUuid &lhs, const QUuid &rhs) |
| QDataStream & | operator<<(QDataStream &s, const QUuid &id) |
| QDebug | operator<<(QDebug dbg, const QUuid &id) |
| bool | operator<=(const QUuid &lhs, const QUuid &rhs) |
| bool | operator==(const QUuid &lhs, const GUID &rhs) |
| bool | operator==(const QUuid &lhs, const QUuid &rhs) |
| bool | operator>(const QUuid &lhs, const QUuid &rhs) |
| bool | operator>=(const QUuid &lhs, const QUuid &rhs) |
| QDataStream & | operator>>(QDataStream &s, QUuid &id) |
Descripción detallada
El uso de Identificadores Universales Únicos(UUID) es una forma estándar de identificar entidades de forma única en un entorno informático distribuido. Un UUID es un número de 16 bytes (128 bits) generado por algún algoritmo que pretende garantizar que el UUID será único en el entorno informático distribuido donde se utilice. A menudo se utiliza en su lugar el acrónimo GUID, Globally Unique IDentifiers, pero se refiere a lo mismo.
En realidad, el GUID es una variante del UUID. Existen múltiples variantes. Cada UUID contiene un campo de bits que especifica de qué tipo (variante) de UUID se trata. Llama a variant() para descubrir qué tipo de UUID contiene una instancia de QUuid. Extrae los tres bits más significativos del byte 8 de los 16 bytes. En QUuid, el byte 8 es QUuid::data4[0]. Si creas instancias de QUuid utilizando el constructor que acepta todos los valores numéricos como parámetros, utiliza la siguiente tabla para establecer los tres bits más significativos del parámetro b1, que se convierte en QUuid::data4[0] y contiene el campo variante en sus tres bits más significativos. En la tabla, 'x' significa don't care.
| msb0 | msb1 | msb2 | Variante |
|---|---|---|---|
| 0 | x | x | NCS (Sistema Informático de Red) |
| 1 | 0 | x | DCE (Entorno informático distribuido) |
| 1 | 1 | 0 | Microsoft (GUID) |
| 1 | 1 | 1 | Reservado para futuras ampliaciones |
Si variant() devuelve QUuid::DCE, el UUID también contiene un campo de versión en los cuatro bits más significativos de QUuid::data3, y puedes llamar a version() para descubrir qué versión contiene tu QUuid. Si creas instancias de QUuid utilizando el constructor que acepta todos los valores numéricos como parámetros, utiliza la siguiente tabla para establecer los cuatro bits más significativos del parámetro w2, que se convierte en QUuid::data3 y contiene el campo de versión en sus cuatro bits más significativos.
| msb0 | msb1 | msb2 | msb3 | Versión |
|---|---|---|---|---|
| 0 | 0 | 0 | 1 | Hora |
| 0 | 0 | 1 | 0 | POSIX integrado |
| 0 | 0 | 1 | 1 | Md5(Nombre) |
| 0 | 1 | 0 | 0 | Aleatorio |
| 0 | 1 | 0 | 1 | Sha1 |
La disposición de los campos para las versiones DCE enumeradas en la tabla anterior se especifica en la Especificación UUID del Grupo de Trabajo de Redes.
La mayoría de las plataformas proporcionan una herramienta para generar nuevos UUID, por ejemplo uuidgen y guidgen. También se puede utilizar createUuid(). Los UUID generados por createUuid() son de tipo aleatorio. Sus bits QUuid::Version se establecen en QUuid::Random, y sus bits QUuid::Variant se establecen en QUuid::DCE. El resto del UUID se compone de números aleatorios. Teóricamente, esto significa que hay una pequeña posibilidad de que un UUID generado por createUuid() no sea único. Pero es una posibilidad muy pequeña.
Los UUID pueden construirse a partir de valores numéricos o de cadenas, o utilizando la función estática createUuid(). Pueden convertirse en una cadena con toString(). Los UUIDs tienen un variant() y un version(), y los UUIDs nulos devuelven true desde isNull().
Documentación de tipos de miembros
enum QUuid::StringFormat
Este enum es utilizado por toString(StringFormat) para controlar el formato de la representación de la cadena. Los valores posibles son
| Constante | Valor | Descripción |
|---|---|---|
QUuid::WithBraces | 0 | Por defecto, toString() devolverá cinco campos hexadecimales, separados por guiones y rodeados de llaves. Ejemplo: {00000000-0000-0000-0000-000000000000}. |
QUuid::WithoutBraces | 1 | Sólo los cinco campos separados por guiones, sin los corchetes. Example: 00000000-0000-0000-0000-000000000000. |
QUuid::Id128 | 3 | Sólo los dígitos hexadecimales, sin llaves ni guiones. Tenga en cuenta que QUuid no puede volver a parsear esto como entrada. |
enum QUuid::Variant
Este enum define los valores utilizados en variant field del UUID. El valor del campo variant determina la disposición del valor de 128 bits.
| Constante | Valor | Descripción |
|---|---|---|
QUuid::VarUnknown | -1 | Variante desconocida |
QUuid::NCS | 0 | Reservado para compatibilidad con versiones anteriores de NCS (Network Computing System) |
QUuid::DCE | 2 | Entorno informático distribuido, el esquema utilizado por QUuid |
QUuid::Microsoft | 6 | Reservado para compatibilidad con versiones anteriores de Microsoft (GUID) |
QUuid::Reserved | 7 | Reservado para futura definición |
enum QUuid::Version
Este enum define los valores utilizados en version field del UUID. El campo versión sólo tiene sentido si el valor en variant field es QUuid::DCE.
| Constante | Valor | Descripción |
|---|---|---|
QUuid::VerUnknown | -1 | Versión desconocida |
QUuid::Time | 1 | Basada en el tiempo, utilizando la marca de tiempo, la secuencia de reloj y la dirección MAC de la tarjeta de red (si está disponible) para las secciones del nodo |
QUuid::EmbeddedPOSIX | 2 | Versión de seguridad DCE, con POSIX UUID incrustados |
QUuid::Name | Md5 | Basada en el nombre, utilizando los valores de un nombre para todas las secciones |
QUuid::Md5 | 3 | Alias para el nombre |
QUuid::Random | 4 | Basada en el azar, utilizando números aleatorios para todas las secciones |
QUuid::Sha1 | 5 | Versión basada en nombres que utiliza hash SHA-1 |
QUuid::UnixEpoch | 7 | [desde 6.9] UUID basado en el tiempo que utiliza el número de milisegundos desde la época UNIX |
Documentación de las funciones miembro
[constexpr noexcept] QUuid::QUuid()
Crea el UUID nulo. toString() mostrará el UUID nulo como "{00000000-0000-0000-0000-000000000000}".
[explicit noexcept] QUuid::QUuid(QAnyStringView text)
Crea un objeto QUuid a partir de la cadena text, que debe formatearse como cinco campos hexadecimales separados por '-', por ejemplo, "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx}" donde cada 'x' es un dígito hexadecimal. Las llaves mostradas aquí son opcionales, pero es normal incluirlas. Si la conversión falla, se crea un UUID nulo. Véase toString() para una explicación de cómo los cinco campos hexadecimales se corresponden con los miembros de datos públicos en QUuid.
Nota: En versiones de Qt anteriores a la 6.3, este constructor era un conjunto de sobrecargas formado por QString, QByteArray y const char* en lugar de un constructor que tomaba QAnyStringView.
Véase también toString() y QUuid().
[constexpr noexcept] QUuid::QUuid(const GUID &guid)
Convierte un guid de Windows en un QUuid de Qt.
Advertencia: Esta función es sólo para plataformas Windows.
[explicit noexcept, since 6.6] QUuid::QUuid(QUuid::Id128Bytes id128, QSysInfo::Endian order = QSysInfo::BigEndian)
Crea un QUuid basado en el parámetro integral id128. Se considera que el parámetro de entrada id128 tiene el orden de bytes order.
Esta función se introdujo en Qt 6.6.
Véase también fromBytes(), toBytes(), toRfc4122(), y toUInt128().
[constexpr noexcept] QUuid::QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8)
Crea un UUID con el valor especificado por los parámetros, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8.
Ejemplo:
// {67C8770B-44F1-410A-AB9A-F9B5446F13EE} QUuid IID_MyInterface(0x67c8770b, 0x44f1, 0x410a, 0xab, 0x9a, 0xf9, 0xb5, 0x44, 0x6f, 0x13, 0xee);
[static] QUuid QUuid::createUuid()
En cualquier plataforma que no sea Windows, esta función devuelve un nuevo UUID con la variante QUuid::DCE y la versión QUuid::Random. En Windows, se genera un UUID utilizando la API de Windows y será del tipo que la API decida crear.
Véase también variant() y version().
[static noexcept] QUuid QUuid::createUuidV3(QUuid ns, QByteArrayView baseData)
Esta función devuelve un nuevo UUID con la variante QUuid::DCE y la versión QUuid::Md5. ns es el espacio de nombres y baseData son los datos básicos descritos por RFC 4122.
Nota: En versiones de Qt anteriores a la 6.8, esta función tomaba QByteArray, no QByteArrayView.
Véase también variant(), version(), createUuidV5(), y createUuidV7().
[static] QUuid QUuid::createUuidV3(const QUuid &ns, const QString &baseData)
Esta función devuelve un nuevo UUID con la variante QUuid::DCE y la versión QUuid::Md5. ns es el espacio de nombres y baseData son los datos básicos descritos por RFC 4122.
Véase también variant(), version(), createUuidV5(), y createUuidV7().
[static noexcept] QUuid QUuid::createUuidV5(QUuid ns, QByteArrayView baseData)
Esta función devuelve un nuevo UUID con la variante QUuid::DCE y la versión QUuid::Sha1. ns es el espacio de nombres y baseData son los datos básicos descritos por RFC 4122.
Nota: En versiones de Qt anteriores a la 6.8, esta función tomaba QByteArray, no QByteArrayView.
Véase también variant(), version(), y createUuidV3().
[static] QUuid QUuid::createUuidV5(const QUuid &ns, const QString &baseData)
Esta función devuelve un nuevo UUID con la variante QUuid::DCE y la versión QUuid::Sha1. ns es el espacio de nombres y baseData son los datos básicos descritos por RFC 4122.
Véase también variant(), version(), y createUuidV3().
[static, since 6.9] QUuid QUuid::createUuidV7()
Esta función devuelve un nuevo UUID con la variante QUuid::DCE y la versión QUuid::UnixEpoch.
Utiliza un campo de valor ordenado por tiempo derivado del número de milisegundos desde el UNIX Epoch tal y como se describe en RFC9562.
Esta función se introdujo en Qt 6.9.
Véase también variant(), version(), createUuidV3(), y createUuidV5().
[static, since 6.6] QUuid QUuid::fromBytes(const void *bytes, QSysInfo::Endian order = QSysInfo::BigEndian)
Lee 128 bits (16 bytes) de bytes utilizando el orden de bytes order y devuelve el QUuid correspondiente a esos bytes. Esta función hace lo mismo que fromRfc4122() si el orden de bytes order es QSysInfo::BigEndian.
Esta función se introdujo en Qt 6.6.
Véase también fromRfc4122().
[static] QUuid QUuid::fromCFUUID(CFUUIDRef uuid)
Construye un nuevo QUuid que contiene una copia del CFUUID de uuid.
Nota: esta función sólo está disponible en plataformas Apple.
[static] QUuid QUuid::fromNSUUID(const NSUUID *uuid)
Construye un nuevo QUuid que contiene una copia del uuid NSUUID.
Nota: esta función sólo está disponible en plataformas Apple.
[static noexcept] QUuid QUuid::fromRfc4122(QByteArrayView bytes)
Crea un objeto QUuid a partir de la representación binaria del UUID, como se especifica en RFC 4122 sección 4.1.2. Véase toRfc4122() para una explicación más detallada del orden de bytes requerido.
La matriz de bytes aceptada NO es un formato legible por humanos.
Si la conversión falla, se crea un UUID nulo.
Nota: En versiones de Qt anteriores a la 6.3, esta función tomaba QByteArray, no QByteArrayView.
Véase también toRfc4122(), QUuid(), y fromBytes().
[static noexcept] QUuid QUuid::fromString(QAnyStringView string)
Crea un objeto QUuid a partir de la cadena string, que debe formatearse como cinco campos hexadecimales separados por '-', por ejemplo, "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx}" donde cada 'x' es un dígito hexadecimal. Las llaves mostradas aquí son opcionales, pero es normal incluirlas. Si la conversión falla, se devuelve un UUID nulo. Véase toString() para una explicación de cómo los cinco campos hexadecimales se corresponden con los miembros de datos públicos en QUuid.
Nota: En versiones de Qt anteriores a la 6.3, esta función era un conjunto de sobrecargas formado por QStringView y QLatin1StringView en lugar de una función que tomaba QAnyStringView.
Véase también toString() y QUuid().
[static constexpr noexcept, since 6.6] QUuid QUuid::fromUInt128(quint128 uuid, QSysInfo::Endian order = QSysInfo::BigEndian)
Crea un QUuid basado en el parámetro integral uuid. Se considera que el parámetro de entrada uuid tiene el orden de byte order.
Nota: Esta función sólo está presente en plataformas que ofrecen un tipo entero de 128 bits.
Esta función se introdujo en Qt 6.6.
Véase también toUInt128(), fromBytes(), toBytes(), y toRfc4122().
[constexpr noexcept] bool QUuid::isNull() const
Devuelve true si se trata del UUID nulo {00000000-0000-0000-0000-000000000000}; en caso contrario devuelve false.
QByteArray QUuid::toByteArray(QUuid::StringFormat mode = WithBraces) const
Devuelve la representación en cadena de este QUuid, con el formato controlado por el parámetro mode. De izquierda a derecha, los cinco campos hexadecimales se obtienen de los cuatro miembros de datos públicos en QUuid de la siguiente manera:
| Campo # | Fuente |
|---|---|
| 1 | datos1 |
| 2 | datos2 |
| 3 | datos3 |
| 4 | datos4[0] .. datos4[1] |
| 5 | datos4[2] .. datos4[7] |
[noexcept, since 6.6] QUuid::Id128Bytes QUuid::toBytes(QSysInfo::Endian order = QSysInfo::BigEndian) const
Devuelve un ID de 128 bits creado a partir de este QUuid en el orden de bytes especificado por order. El contenido binario de esta función es el mismo que toRfc4122() si el orden es QSysInfo::BigEndian. Véase esa función para más detalles.
Esta función se introdujo en Qt 6.6.
Véase también toRfc4122(), fromBytes(), y QUuid().
CFUUIDRef QUuid::toCFUUID() const
Crea un CFUUID a partir de QUuid.
El llamador es el propietario del CFUUID y es responsable de liberarlo.
Nota: esta función sólo está disponible en plataformas Apple.
NSUUID *QUuid::toNSUUID() const
Crea un NSUUID a partir de QUuid.
El NSUUID se libera automáticamente.
Nota: esta función sólo está disponible en plataformas Apple.
QByteArray QUuid::toRfc4122() const
Devuelve la representación binaria de este QUuid. La matriz de bytes está en formato big endian, y formateada según RFC 4122, sección 4.1.2 - "Layout and byte order".
El orden es el siguiente
| Campo # | Fuente |
|---|---|
| 1 | datos1 |
| 2 | datos2 |
| 3 | datos3 |
| 4 | datos4[0] .. datos4[7] |
Los bytes de la matriz de bytes devuelta por esta función tienen el mismo contenido binario que toBytes().
Véase también toBytes().
QString QUuid::toString(QUuid::StringFormat mode = WithBraces) const
Devuelve la representación en cadena de este QUuid, con el formato controlado por el parámetro mode. De izquierda a derecha, los cinco campos hexadecimales se obtienen de los cuatro miembros de datos públicos en QUuid de la siguiente manera:
| Campo # | Fuente |
|---|---|
| 1 | datos1 |
| 2 | datos2 |
| 3 | datos3 |
| 4 | datos4[0] .. datos4[1] |
| 5 | datos4[2] .. datos4[7] |
[constexpr noexcept, since 6.6] quint128 QUuid::toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const
Devuelve un entero de 128 bits creado a partir de este QUuid en el orden de bytes especificado por order. El contenido binario de esta función es el mismo que toRfc4122() si el orden es QSysInfo::BigEndian. Consulte esa función para más detalles.
Nota: Esta función sólo está presente en plataformas que ofrecen un tipo entero de 128 bits.
Esta función se introdujo en Qt 6.6.
Véase también toRfc4122(), fromUInt128(), toBytes(), fromBytes(), y QUuid().
[constexpr noexcept] QUuid::Variant QUuid::variant() const
Devuelve el valor en variant field del UUID. Si el valor devuelto es QUuid::DCE, llame a version() para ver qué variante utiliza. El UUID nulo se considera de variante desconocida.
Véase también version().
[constexpr noexcept] QUuid::Version QUuid::version() const
Devuelve el version field del UUID, si el variant field del UUID es QUuid::DCE. En caso contrario, devuelve QUuid::VerUnknown.
Véase también variant().
[constexpr noexcept] QUuid::operator GUID() const
Devuelve un GUID de Windows de un QUuid.
Advertencia: Esta función es sólo para plataformas Windows.
[constexpr noexcept] QUuid &QUuid::operator=(const GUID &guid)
Asigna un guid de Windows a un QUuid de Qt .
Advertencia: Esta función es sólo para plataformas Windows.
No miembros relacionados
[noexcept] size_t qHash(const QUuid &key, size_t seed = 0)
Devuelve el valor hash para key, utilizando seed para sembrar el cálculo.
[constexpr noexcept] bool operator!=(const QUuid &lhs, const GUID &rhs)
Devuelve true si lhs UUID no es igual al GUID de Windows rhs; en caso contrario devuelve false.
[constexpr noexcept] bool operator!=(const QUuid &lhs, const QUuid &rhs)
Devuelve true si lhs QUuid y el rhs QUuid son diferentes; en caso contrario devuelve false.
[constexpr noexcept] bool operator<(const QUuid &lhs, const QUuid &rhs)
[constexpr noexcept] bool operator>(const QUuid &lhs, const QUuid &rhs)
[constexpr noexcept] bool operator<=(const QUuid &lhs, const QUuid &rhs)
[constexpr noexcept] bool operator>=(const QUuid &lhs, const QUuid &rhs)
Realiza una comparación de lhs contra rhs y devuelve true si la ordenación relativa de lhs y rhs es correcta para la operación en cuestión, false en caso contrario. Tenga en cuenta que la ordenación realizada por esta función puede no ser igual a la ordenación de las cadenas creadas por toString(), ni a la de los enteros toId128(), ni a la de la matriz de bytes devuelta por toBytes() y toRfc4122().
Véase también variant().
QDataStream &operator<<(QDataStream &s, const QUuid &id)
Escribe el UUID id en el flujo de datos s.
QDebug operator<<(QDebug dbg, const QUuid &id)
Escribe el UUID id en el flujo de salida para información de depuración dbg.
[constexpr noexcept] bool operator==(const QUuid &lhs, const GUID &rhs)
Devuelve true si lhs UUID es igual al GUID de Windows rhs; en caso contrario devuelve false.
[constexpr noexcept] bool operator==(const QUuid &lhs, const QUuid &rhs)
Devuelve true si lhs QUuid y el rhs QUuid son idénticos; en caso contrario devuelve false.
QDataStream &operator>>(QDataStream &s, QUuid &id)
Lee un UUID del flujo s en id.
© 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.
