QUuid Class
La clase QUuid almacena un identificador único universal (UUID). Más información...
| Encabezado: | #include <QUuid> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Heredado por: |
Nota: Todas las funciones de esta clase son reentrantes.
Comparaciones de QUuid
| Categoría | Tipos comparables | Descripción |
|---|---|---|
| strong | QUuid | |
| strong | GUID. | Nota: La comparación con GUID solo es posible en Windows. |
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) |
Elementos 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 universalmente únicos(UUID) es una forma estándar de identificar de manera única entidades en un entorno informático distribuido. Un UUID es un número de 16 bytes (128 bits) generado por un algoritmo destinado a garantizar que el UUID sea único en el entorno informático distribuido en el que se utiliza. A menudo se utiliza en su lugar el acrónimo GUID ( identificadores globalmente únicos), pero se refiere a lo mismo.
En realidad, el GUID es una variante del UUID. Se utilizan múltiples variantes. Cada UUID contiene un campo de bits que especifica de qué tipo (variante) de UUID se trata. Llama a ` variant()` para averiguar qué tipo de UUID contiene una instancia de `QUuid`. Esta función 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 de variante en sus tres bits más significativos. En la tabla, «x» significa «indiferente».
| msb0 | msb1 | msb2 | Variant |
|---|---|---|---|
| 0 | x | x | NCS (Sistema Informático en 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 averiguar 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 |
Las estructuras de los campos para las versiones de DCE que figuran en la tabla anterior se especifican en la Especificación de UUID del Grupo de Trabajo de Redes.
La mayoría de las plataformas ofrecen 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 están establecidos en QUuid::Random, y sus bits QUuid::Variant están establecidos en QUuid::DCE. El resto del UUID se compone de números aleatorios. Teóricamente, esto significa que existe una pequeña probabilidad de que un UUID generado por createUuid() no sea único. Pero se trata de una probabilidad muy baja.
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 UUID tienen un variant() y un version(), y los UUID nulos devuelven «true» al llamar a isNull().
Documentación sobre los tipos de miembros
enum QUuid::StringFormat
toString(StringFormat) utiliza esta enumeración 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 entre llaves. Ejemplo: {00000000-0000-0000-0000-000000000000}. |
QUuid::WithoutBraces | 1 | Solo los cinco campos separados por guiones, sin las llaves. Ejemplo: 00000000-0000-0000-0000-000000000000. |
QUuid::Id128 | 3 | Solo los dígitos hexadecimales, sin llaves ni guiones. Ten en cuenta que QUuid no puede volver a interpretar esto como entrada. |
enum QUuid::Variant
Esta enumeración define los valores utilizados en la parte « variant field » del UUID. El valor del campo «variant» determina la estructura del valor de 128 bits.
| Constante | Valor | Descripción |
|---|---|---|
QUuid::VarUnknown | -1 | La variante es desconocida |
QUuid::NCS | 0 | Reservado para la compatibilidad con versiones anteriores de NCS (Network Computing System) |
QUuid::DCE | 2 | Entorno de computación distribuida, el esquema utilizado por QUuid |
QUuid::Microsoft | 6 | Reservado para la compatibilidad con versiones anteriores de Microsoft (GUID) |
QUuid::Reserved | 7 | Reservado para definición futura |
enum QUuid::Version
Esta enumeración define los valores utilizados en el campo « version field » del UUID. El campo «version» solo tiene sentido si el valor del campo « variant field » es « QUuid::DCE ».
| Constante | Valor | Descripción |
|---|---|---|
QUuid::VerUnknown | -1 | Se desconoce la versión |
QUuid::Time | 1 | Basada en el tiempo, utilizando la marca de tiempo, la secuencia del reloj y la dirección MAC de la tarjeta de red (si está disponible) para las secciones de nodo |
QUuid::EmbeddedPOSIX | 2 | Versión de seguridad DCE, con UUID de POSIX incrustados |
QUuid::Name | Md5 | Basado en el nombre, utilizando valores de un nombre para todas las secciones |
QUuid::Md5 | 3 | Alias para el nombre |
QUuid::Random | 4 | Basada en aleatoriedad, utilizando números aleatorios para todas las secciones |
QUuid::Sha1 | 5 | Versión basada en el nombre que utiliza el hash SHA-1 |
QUuid::UnixEpoch | 7 | [desde la versión 6.9] UUID basado en el tiempo que utiliza el número de milisegundos transcurridos desde la época UNIX |
Documentación de las funciones miembro
[constexpr noexcept] QUuid::QUuid()
Crea el UUID nulo. La función ` 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 tener el formato de cinco campos hexadecimales separados por «-», por ejemplo, «{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}», donde cada «x» es un dígito hexadecimal. Las llaves que se muestran aquí son opcionales, pero lo habitual es incluirlas. Si la conversión falla, se crea un UUID nulo. Consulte toString() para obtener una explicación de cómo se asignan los cinco campos hexadecimales a los miembros de datos públicos de QUuid.
Nota: En las 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 único constructor que aceptaba QAnyStringView.
Véanse también toString() y QUuid().
[constexpr noexcept] QUuid::QUuid(const GUID &guid)
Convierte un objeto « guid » de Windows en un «QUuid» de Qt.
Advertencia: Esta función solo es válida para plataformas Windows.
[explicit noexcept, since 6.6] QUuid::QUuid(QUuid::Id128Bytes id128, QSysInfo::Endian order = QSysInfo::BigEndian)
Crea un QUuid a partir del parámetro entero 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éanse 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 GUID mediante la API de Windows y será del tipo que la API decida crear.
Véanse 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, tal y como se describen en el RFC 4122.
Nota: En las versiones de Qt anteriores a la 6.8, esta función aceptaba QByteArray, en lugar de 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, tal y como se describen en el RFC 4122.
Véanse 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, tal y como se describen en el RFC 4122.
Nota: En las versiones de Qt anteriores a la 6.8, esta función aceptaba QByteArray, en lugar de 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, tal y como se describen en el RFC 4122.
Véanse 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 temporalmente derivado del número de milisegundos transcurridos desde la Época UNIX, tal y como se describe en el RFC 9562.
Esta función se introdujo en Qt 6.9.
Véanse 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 realiza 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)
Crea un nuevo objeto « QUuid » que contiene una copia del CFUUID « uuid ».
Nota: esta función solo está disponible en plataformas de Apple.
[static] QUuid QUuid::fromNSUUID(const NSUUID *uuid)
Crea un nuevo objeto ` QUuid ` que contiene una copia del NSUUID de ` uuid `.
Nota: esta función solo está disponible en plataformas de Apple.
[static noexcept] QUuid QUuid::fromRfc4122(QByteArrayView bytes)
Crea un objeto ` QUuid ` a partir de la representación binaria del UUID, tal y como se especifica en la sección 4.1.2 del RFC 4122. Consulta toRfc4122() para obtener una explicación más detallada del orden de los caracteres « bytes » requeridos.
La matriz de bytes aceptada NO está en un formato legible para el ser humano.
Si la conversión falla, se crea un UUID nulo.
Nota: En las versiones de Qt anteriores a la 6.3, esta función aceptaba « QByteArray », no « QByteArrayView ».
Véanse 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 tener el formato de cinco campos hexadecimales separados por «-», por ejemplo, «{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}», donde cada «x» es un dígito hexadecimal. Las llaves que se muestran aquí son opcionales, pero lo habitual es incluirlas. Si la conversión falla, se devuelve un UUID nulo. Consulta toString() para obtener una explicación de cómo se asignan los cinco campos hexadecimales a los miembros de datos públicos de QUuid.
Nota: En las 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 única función que aceptaba 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 objeto ` QUuid ` basado en el parámetro entero ` uuid `. Se considera que el parámetro de entrada ` uuid ` tiene el orden de bytes ` order`.
Nota: Esta función solo está disponible 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 forma de cadena de este ` QUuid`, con el formato controlado por el parámetro ` mode `. De izquierda a derecha, los cinco campos hexadecimales se obtienen a partir de los cuatro miembros de datos públicos de ` QUuid ` de la siguiente manera:
| Campo n.º | Fuente |
|---|---|
| 1 | data1 |
| 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 identificador de 128 bits creado a partir de este ` QUuid ` con el orden de bytes especificado por ` order`. El contenido binario de esta función es el mismo que el de ` toRfc4122()` si el orden es ` QSysInfo::BigEndian`. Consulta esa función para obtener más detalles.
Esta función se introdujo en Qt 6.6.
Véanse también toRfc4122(), fromBytes() y QUuid().
CFUUIDRef QUuid::toCFUUID() const
Crea un CFUUID a partir de un « QUuid ».
El autor de la llamada es el propietario del CFUUID y es responsable de liberarlo.
Nota: esta función solo está disponible en plataformas de Apple.
NSUUID *QUuid::toNSUUID() const
Crea un NSUUID a partir de un « QUuid ».
El NSUUID se libera automáticamente.
Nota: esta función solo está disponible en plataformas de Apple.
QByteArray QUuid::toRfc4122() const
Devuelve la representación binaria de este QUuid. La matriz de bytes está en formato «big endian» y se ha formateado de acuerdo con la RFC 4122, sección 4.1.2: «Diseño y orden de los bytes».
El orden es el siguiente:
| Campo n.º | Origen |
|---|---|
| 1 | datos1 |
| 2 | datos2 |
| 3 | datos3 |
| 4 | datos4[0] .. datos4[7] |
Los bytes de la matriz de bytes devuelta por esta función contienen el mismo contenido binario que toBytes().
Véase también toBytes().
QString QUuid::toString(QUuid::StringFormat mode = WithBraces) const
Devuelve la representación en forma de cadena de este ` QUuid`, con el formato controlado por el parámetro ` mode `. De izquierda a derecha, los cinco campos hexadecimales se obtienen a partir de los cuatro miembros de datos públicos de ` QUuid ` de la siguiente manera:
| Campo n.º | Fuente |
|---|---|
| 1 | data1 |
| 2 | datos2 |
| 3 | dato3 |
| 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 ` con el orden de bytes especificado por ` order`. El contenido binario de esta función es el mismo que el de ` toRfc4122()` si el orden es ` QSysInfo::BigEndian`. Consulta esa función para obtener más detalles.
Nota: Esta función solo está disponible en plataformas que ofrecen un tipo de entero de 128 bits.
Esta función se introdujo en Qt 6.6.
Véanse también toRfc4122(), fromUInt128(), toBytes(), fromBytes() y QUuid().
[constexpr noexcept] QUuid::Variant QUuid::variant() const
Devuelve el valor de la parte « variant field » del UUID. Si el valor devuelto es « QUuid::DCE », llama a version() para ver qué estructura utiliza. El UUID nulo se considera de una variante desconocida.
Véase también version().
[constexpr noexcept] QUuid::Version QUuid::version() const
Devuelve el « version field » del UUID, si la « 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 a partir de un ` QUuid`.
Advertencia: Esta función solo está disponible para plataformas Windows.
[constexpr noexcept] QUuid &QUuid::operator=(const GUID &guid)
Asigna un objeto ` guid ` de Windows a un objeto ` QUuid` de Qt XML.
Advertencia: Esta función solo está disponible para plataformas Windows.
Elementos no miembros relacionados
[noexcept] size_t qHash(const QUuid &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] bool operator!=(const QUuid &lhs, const GUID &rhs)
Devuelve « true » si el UUID lhs 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 « 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 entre lhs y rhs y devuelve true si el orden relativo de lhs y rhs es correcto para la operación en cuestión; en caso contrario, devuelve false. Ten en cuenta que el orden establecido por esta función puede no coincidir con el orden de las cadenas creadas por toString(), ni con el de los enteros generados por toId128(), ni con el 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 obtener información de depuración dbg.
[constexpr noexcept] bool operator==(const QUuid &lhs, const GUID &rhs)
Devuelve ` true ` si el UUID de ` lhs ` 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 ` rhs ` ` QUuid ` son idénticos; en caso contrario, devuelve ` false`.
QDataStream &operator>>(QDataStream &s, QUuid &id)
Lee un UUID del flujo s y lo guarda 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.