QUuid Class
La classe QUuid stocke un identifiant universel unique (UUID). Plus d'informations...
| En-tête : | #include <QUuid> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
| Inherited By : |
Cette classe est fortement comparable.
Cette classe est fortement comparable à GUID.
Note : La comparaison avec GUID est réservée à Windows.
Remarque : Toutes les fonctions de cette classe sont réentrantes.
Types publics
(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 } |
Fonctions publiques
| 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) |
Membres publics statiques
| 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) |
Non-membres apparentés
| 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) |
Description détaillée
L'utilisation d'identifiants universels uniques(UUID) est un moyen standard d'identifier de manière unique des entités dans un environnement informatique distribué. Un UUID est un numéro de 16 octets (128 bits) généré par un algorithme censé garantir que l'UUID sera unique dans l'environnement informatique distribué où il est utilisé. L'acronyme GUID ( Globally Unique IDentifiers) est souvent utilisé à la place, mais il fait référence à la même chose.
En fait, le GUID est une variante de l'UUID. Plusieurs variantes sont utilisées. Chaque UUID contient un champ de bits qui spécifie de quel type (variante) d'UUID il s'agit. Appelez variant() pour découvrir le type d'UUID que contient une instance de QUuid. Il extrait les trois bits les plus significatifs de l'octet 8 des 16 octets. Dans le QUuid, l'octet 8 est QUuid::data4[0]. Si vous créez des instances de QUuid en utilisant le constructeur qui accepte toutes les valeurs numériques comme paramètres, utilisez le tableau suivant pour définir les trois bits les plus significatifs du paramètre b1, qui devient QUuid::data4[0] et contient le champ variante dans ses trois bits les plus significatifs. Dans le tableau, 'x' signifie 'don't care'.
| msb0 | msb1 | msb2 | Variante |
|---|---|---|---|
| 0 | x | x | NCS (Network Computing System) |
| 1 | 0 | x | DCE (environnement de calcul distribué) |
| 1 | 1 | 0 | Microsoft (GUID) |
| 1 | 1 | 1 | Réservé pour une expansion future |
Si variant() renvoie QUuid::DCE, l'UUID contient également un champ de version dans les quatre bits les plus significatifs de QUuid::data3, et vous pouvez appeler version() pour découvrir la version de votre QUuid. Si vous créez des instances de QUuid en utilisant le constructeur qui accepte toutes les valeurs numériques comme paramètres, utilisez le tableau suivant pour définir les quatre bits les plus significatifs du paramètre w2, qui devient QUuid::data3 et contient le champ de version dans ses quatre bits les plus significatifs.
| msb0 | msb1 | msb2 | msb3 | Version |
|---|---|---|---|---|
| 0 | 0 | 0 | 1 | Temps |
| 0 | 0 | 1 | 0 | POSIX intégré |
| 0 | 0 | 1 | 1 | Md5(Nom) |
| 0 | 1 | 0 | 0 | Aléatoire |
| 0 | 1 | 0 | 1 | Sha1 |
La disposition des champs pour les versions DCE énumérées dans le tableau ci-dessus est précisée dans la spécification UUID du groupe de travail sur les réseaux.
La plupart des plateformes fournissent un outil permettant de générer de nouveaux UUID, par exemple uuidgen et guidgen. Vous pouvez également utiliser createUuid(). Les UUID générés par createUuid() sont de type aléatoire. Leurs bits QUuid::Version sont mis à QUuid::Random et leurs bits QUuid::Variant sont mis à QUuid::DCE. Le reste de l'UUID est composé de nombres aléatoires. Théoriquement, cela signifie qu'il y a une faible probabilité qu'un UUID généré par createUuid() ne soit pas unique. Mais ce risque est très faible.
Les UUID peuvent être construits à partir de valeurs numériques ou de chaînes de caractères, ou en utilisant la fonction statique createUuid(). Ils peuvent être convertis en chaîne de caractères à l'aide de la fonction toString(). Les UUID ont une fonction variant() et une fonction version(), et les UUID nuls renvoient la valeur true de la fonction isNull().
Documentation sur les types de membres
enum QUuid::StringFormat
Cette énumération est utilisée par toString(StringFormat) pour contrôler le formatage de la représentation de la chaîne. Les valeurs possibles sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QUuid::WithBraces | 0 | Par défaut, toString() renvoie cinq champs hexadécimaux, séparés par des tirets et entourés d'accolades. Exemple : {-0000-0000-0000-} : {00000000-0000-0000-0000-000000000000}. |
QUuid::WithoutBraces | 1 | Uniquement les cinq champs séparés par des tirets, sans les accolades. Example: 00000000-0000-0000-0000-000000000000. |
QUuid::Id128 | 3 | Uniquement les chiffres hexadécimaux, sans accolades ni tirets. Notez que QUuid ne peut pas analyser ces données en entrée. |
enum QUuid::Variant
Cette énumération définit les valeurs utilisées dans le site variant field de l'UUID. La valeur du champ variante détermine la disposition de la valeur de 128 bits.
| Constante | Valeur | Description de la valeur |
|---|---|---|
QUuid::VarUnknown | -1 | Variante inconnue |
QUuid::NCS | 0 | Réservé pour la compatibilité ascendante NCS (Network Computing System) |
QUuid::DCE | 2 | Environnement informatique distribué, le système utilisé par Microsoft. QUuid |
QUuid::Microsoft | 6 | Réservé pour la rétrocompatibilité Microsoft (GUID) |
QUuid::Reserved | 7 | Réservé pour une définition future |
enum QUuid::Version
Cette énumération définit les valeurs utilisées dans version field de l'UUID. Le champ version n'est significatif que si la valeur de variant field est QUuid::DCE.
| Constante | Valeur | Description de l'UUID |
|---|---|---|
QUuid::VerUnknown | -1 | La version est inconnue |
QUuid::Time | 1 | Basée sur le temps, en utilisant l'horodatage, la séquence d'horloge et l'adresse de la carte réseau MAC (si elle est disponible) pour les sections du nœud. |
QUuid::EmbeddedPOSIX | 2 | Version de sécurité DCE, avec UUID POSIX intégrés |
QUuid::Name | Md5 | Basée sur le nom, en utilisant les valeurs d'un nom pour toutes les sections |
QUuid::Md5 | 3 | Alias pour le nom |
QUuid::Random | 4 | basé sur des nombres aléatoires, en utilisant des nombres aléatoires pour toutes les sections |
QUuid::Sha1 | 5 | Version basée sur le nom qui utilise le hachage SHA-1 |
QUuid::UnixEpoch | 7 | [depuis la version 6.9] UUID basé sur le temps, utilisant le nombre de millisecondes depuis l'époque UNIX |
Documentation des fonctions membres
[constexpr noexcept] QUuid::QUuid()
Crée l'UUID nul. toString() affichera l'UUID nul sous la forme "{00000000-0000-0000-0000-000000000000}".
[explicit noexcept] QUuid::QUuid(QAnyStringView text)
Crée un objet QUuid à partir de la chaîne text, qui doit être formatée en cinq champs hexagonaux séparés par des '-', par exemple, "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}" où chaque 'x' est un chiffre hexagonal. Les accolades indiquées ici sont facultatives, mais il est normal de les inclure. Si la conversion échoue, un UUID nul est créé. Voir toString() pour une explication de la correspondance entre les cinq champs hexadécimaux et les membres de données publiques de QUuid.
Note : Dans les versions de Qt XML antérieures à la 6.3, ce constructeur était un ensemble de surcharges composé de QString, QByteArray et const char* au lieu d'un seul constructeur prenant QAnyStringView.
Voir aussi toString() et QUuid().
[constexpr noexcept] QUuid::QUuid(const GUID &guid)
Transforme un Windows guid en un Qt QUuid.
Attention : Cette fonction n'est disponible que pour les plates-formes Windows.
[explicit noexcept, since 6.6] QUuid::QUuid(QUuid::Id128Bytes id128, QSysInfo::Endian order = QSysInfo::BigEndian)
Crée un QUuid basé sur le paramètre intégral id128. Le paramètre d'entrée id128 est considéré comme ayant l'ordre des octets order.
Cette fonction a été introduite dans Qt 6.6.
Voir aussi fromBytes(), toBytes(), toRfc4122(), et 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)
Crée un UUID avec la valeur spécifiée par les paramètres l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8.
Exemple :
// {67C8770B-44F1-410A-AB9A-F9B5446F13EE} QUuid IID_MyInterface(0x67c8770b, 0x44f1, 0x410a, 0xab, 0x9a, 0xf9, 0xb5, 0x44, 0x6f, 0x13, 0xee);
[static] QUuid QUuid::createUuid()
Sur toute plate-forme autre que Windows, cette fonction renvoie un nouvel UUID avec la variante QUuid::DCE et la version QUuid::Random. Sous Windows, un GUID est généré à l'aide de l'API Windows et sera du type que l'API décide de créer.
Voir également variant() et version().
[static noexcept] QUuid QUuid::createUuidV3(QUuid ns, QByteArrayView baseData)
Cette fonction renvoie un nouvel UUID avec la variante QUuid::DCE et la version QUuid::Md5. ns est l'espace de noms et baseData est la donnée de base telle que décrite par la RFC 4122.
Note : Dans les versions de Qt antérieures à 6.8, cette fonction prenait QByteArray, et non QByteArrayView.
Voir aussi variant(), version(), createUuidV5() et createUuidV7().
[static] QUuid QUuid::createUuidV3(const QUuid &ns, const QString &baseData)
Cette fonction renvoie un nouvel UUID avec la variante QUuid::DCE et la version QUuid::Md5. ns est l'espace de noms et baseData est la donnée de base telle que décrite par la RFC 4122.
Voir aussi variant(), version(), createUuidV5() et createUuidV7().
[static noexcept] QUuid QUuid::createUuidV5(QUuid ns, QByteArrayView baseData)
Cette fonction renvoie un nouvel UUID avec la variante QUuid::DCE et la version QUuid::Sha1. ns est l'espace de noms et baseData est la donnée de base telle que décrite par la RFC 4122.
Note : Dans les versions de Qt antérieures à 6.8, cette fonction prenait QByteArray, et non QByteArrayView.
Voir aussi variant(), version() et createUuidV3().
[static] QUuid QUuid::createUuidV5(const QUuid &ns, const QString &baseData)
Cette fonction renvoie un nouvel UUID avec la variante QUuid::DCE et la version QUuid::Sha1. ns est l'espace de noms et baseData est la donnée de base telle que décrite par la RFC 4122.
Voir aussi variant(), version() et createUuidV3().
[static, since 6.9] QUuid QUuid::createUuidV7()
Cette fonction renvoie un nouvel UUID avec la variante QUuid::DCE et la version QUuid::UnixEpoch.
Elle utilise un champ de valeurs ordonné dans le temps, dérivé du nombre de millisecondes écoulées depuis l'époque UNIX, tel que décrit par la RFC9562.
Cette fonction a été introduite dans Qt 6.9.
Voir aussi variant(), version(), createUuidV3(), et createUuidV5().
[static, since 6.6] QUuid QUuid::fromBytes(const void *bytes, QSysInfo::Endian order = QSysInfo::BigEndian)
Lit 128 bits (16 octets) dans bytes en utilisant l'ordre des octets order et renvoie le QUuid correspondant à ces octets. Cette fonction fait la même chose que fromRfc4122() si l'ordre des octets order est QSysInfo::BigEndian.
Cette fonction a été introduite dans Qt 6.6.
Voir aussi fromRfc4122().
[static] QUuid QUuid::fromCFUUID(CFUUIDRef uuid)
Construit un nouveau QUuid contenant une copie du CFUUID uuid.
Remarque : cette fonction n'est disponible que sur les plates-formes Apple.
[static] QUuid QUuid::fromNSUUID(const NSUUID *uuid)
Construit un nouveau QUuid contenant une copie du NSUUID uuid.
Remarque : cette fonction n'est disponible que sur les plates-formes Apple.
[static noexcept] QUuid QUuid::fromRfc4122(QByteArrayView bytes)
Crée un objet QUuid à partir de la représentation binaire de l'UUID, comme spécifié dans la RFC 4122 section 4.1.2. Voir toRfc4122() pour une explication plus détaillée de l'ordre de bytes requis.
Le tableau d'octets accepté n'est PAS un format lisible par l'homme.
Si la conversion échoue, un UUID nul est créé.
Remarque : Dans les versions de Qt antérieures à la version 6.3, cette fonction prenait QByteArray, et non QByteArrayView.
Voir aussi toRfc4122(), QUuid() et fromBytes().
[static noexcept] QUuid QUuid::fromString(QAnyStringView string)
Crée un objet QUuid à partir de la chaîne string, qui doit être formatée sous la forme de cinq champs hexagonaux séparés par des '-', par exemple, "{xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx}" où chaque 'x' est un chiffre hexagonal. Les accolades indiquées ici sont facultatives, mais il est normal de les inclure. Si la conversion échoue, un UUID nul est renvoyé. Voir toString() pour une explication de la correspondance entre les cinq champs hexadécimaux et les membres de données publiques dans QUuid.
Remarque : dans les versions de Qt XML antérieures à la version 6.3, cette fonction était un ensemble de surcharges composé de QStringView et QLatin1StringView au lieu d'une fonction prenant QAnyStringView.
Voir aussi toString() et QUuid().
[static constexpr noexcept, since 6.6] QUuid QUuid::fromUInt128(quint128 uuid, QSysInfo::Endian order = QSysInfo::BigEndian)
Crée un QUuid basé sur le paramètre intégral uuid. Le paramètre d'entrée uuid est considéré comme ayant l'ordre des octets order.
Remarque : cette fonction n'est présente que sur les plates-formes qui offrent un type d'entier de 128 bits.
Cette fonction a été introduite dans Qt 6.6.
Voir aussi toUInt128(), fromBytes(), toBytes() et toRfc4122().
[constexpr noexcept] bool QUuid::isNull() const
Renvoie true s'il s'agit de l'UUID null {00000000-0000-0000-0000-000000000000} ; sinon, renvoie false.
QByteArray QUuid::toByteArray(QUuid::StringFormat mode = WithBraces) const
Renvoie la représentation sous forme de chaîne de caractères de cette adresse QUuid, dont le formatage est contrôlé par le paramètre mode. De gauche à droite, les cinq champs hexagonaux sont obtenus à partir des quatre membres de données publiques de QUuid comme suit :
| Champ # | Source |
|---|---|
| 1 | données1 |
| 2 | données2 |
| 3 | données3 |
| 4 | data4[0] .. data4[1] |
| 5 | data4[2] .. data4[7] |
[noexcept, since 6.6] QUuid::Id128Bytes QUuid::toBytes(QSysInfo::Endian order = QSysInfo::BigEndian) const
Renvoie un identifiant de 128 bits créé à partir de QUuid dans l'ordre des octets spécifié par order. Le contenu binaire de cette fonction est le même que celui de toRfc4122() si l'ordre est QSysInfo::BigEndian. Voir cette fonction pour plus de détails.
Cette fonction a été introduite dans Qt 6.6.
Voir aussi toRfc4122(), fromBytes(), et QUuid().
CFUUIDRef QUuid::toCFUUID() const
Crée un CFUUID à partir d'un QUuid.
L'appelant est propriétaire du CFUUID et est responsable de sa libération.
Remarque : cette fonction n'est disponible que sur les plates-formes Apple.
NSUUID *QUuid::toNSUUID() const
Crée une NSUUID à partir d'une QUuid.
La NSUUID est libérée automatiquement.
Remarque : cette fonction n'est disponible que sur les plates-formes Apple.
QByteArray QUuid::toRfc4122() const
Renvoie la représentation binaire de cette adresse QUuid. Le tableau d'octets est au format big endian et formaté conformément à la RFC 4122, section 4.1.2 - "Layout and byte order".
L'ordre est le suivant :
| Champ # | Source |
|---|---|
| 1 | données1 |
| 2 | données2 |
| 3 | données3 |
| 4 | data4[0] .. data4[7] |
Les octets du tableau d'octets renvoyé par cette fonction contiennent le même contenu binaire que toBytes().
Voir également toBytes().
QString QUuid::toString(QUuid::StringFormat mode = WithBraces) const
Renvoie la représentation sous forme de chaîne de caractères de cette adresse QUuid, dont le formatage est contrôlé par le paramètre mode. De gauche à droite, les cinq champs hexagonaux sont obtenus à partir des quatre membres de données publiques de QUuid comme suit :
| Champ # | Source |
|---|---|
| 1 | données1 |
| 2 | données2 |
| 3 | données3 |
| 4 | data4[0] .. data4[1] |
| 5 | data4[2] .. data4[7] |
[constexpr noexcept, since 6.6] quint128 QUuid::toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const
Renvoie un entier de 128 bits créé à partir de QUuid dans l'ordre des octets spécifié par order. Le contenu binaire de cette fonction est le même que celui de toRfc4122() si l'ordre est QSysInfo::BigEndian. Voir cette fonction pour plus de détails.
Remarque : cette fonction n'est présente que sur les plates-formes qui offrent un type d'entier de 128 bits.
Cette fonction a été introduite dans Qt 6.6.
Voir aussi toRfc4122(), fromUInt128(), toBytes(), fromBytes() et QUuid().
[constexpr noexcept] QUuid::Variant QUuid::variant() const
Renvoie la valeur dans variant field de l'UUID. Si la valeur de retour est QUuid::DCE, appelez version() pour voir quelle mise en page est utilisée. L'UUID nul est considéré comme étant d'une variante inconnue.
Voir aussi version().
[constexpr noexcept] QUuid::Version QUuid::version() const
Renvoie l'adresse version field de l'UUID, si l'adresse variant field de l'UUID est QUuid::DCE. Sinon, il renvoie QUuid::VerUnknown.
Voir aussi variant().
[constexpr noexcept] QUuid::operator GUID() const
Renvoie un GUID Windows à partir d'un QUuid.
Attention : Cette fonction n'est disponible que pour les plates-formes Windows.
[constexpr noexcept] QUuid &QUuid::operator=(const GUID &guid)
Attribue un guid Windows à un QUuid Qt .
Attention : Cette fonction ne concerne que les plates-formes Windows.
Non-membres apparentés
[noexcept] size_t qHash(const QUuid &key, size_t seed = 0)
Renvoie la valeur de hachage pour key, en utilisant seed comme base de calcul.
[constexpr noexcept] bool operator!=(const QUuid &lhs, const GUID &rhs)
Renvoie true si lhs UUID n'est pas égal au GUID Windows rhs; sinon renvoie false.
[constexpr noexcept] bool operator!=(const QUuid &lhs, const QUuid &rhs)
Renvoie true si lhs QUuid et rhs QUuid sont différents ; sinon, renvoie 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)
Effectue une comparaison de lhs avec rhs et renvoie true si le tri relatif de lhs et rhs est correct pour l'opération en question, false sinon. Notez que le tri effectué par cette fonction peut ne pas être égal au tri des chaînes créées par toString(), ni aux entiers toId128(), ou au tableau d'octets renvoyé par toBytes() et toRfc4122().
Voir aussi variant().
QDataStream &operator<<(QDataStream &s, const QUuid &id)
Écrit l'UUID id dans le flux de données s.
QDebug operator<<(QDebug dbg, const QUuid &id)
Écrit l'UUID id dans le flux de sortie pour des informations de débogage dbg.
[constexpr noexcept] bool operator==(const QUuid &lhs, const GUID &rhs)
Renvoie true si lhs UUID est égal au GUID Windows rhs; sinon renvoie false.
[constexpr noexcept] bool operator==(const QUuid &lhs, const QUuid &rhs)
Renvoie true si lhs QUuid et rhs QUuid sont identiques ; sinon, renvoie false.
QDataStream &operator>>(QDataStream &s, QUuid &id)
Lit un UUID à partir du flux s dans 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.
