QDataStream Class

Documentation des fonctions membres

QDataStream::QDataStream()

Crée un flux de données ne comportant aucun périphérique d'E/S.

Voir également setDevice().

[explicit] QDataStream::QDataStream(QIODevice *d)

Crée un flux de données utilisant le périphérique d'E/S d.

Voir également setDevice() et device().

QDataStream::QDataStream(const QByteArray &a)

Crée un flux de données en lecture seule qui opère sur un tableau d'octets a. Utilisez QDataStream(QByteArray*, int) si vous souhaitez écrire dans un tableau d'octets.

QByteArray n'étant pas une sous-classe de QIODevice, un objet QBuffer est créé en interne pour encapsuler le tableau d'octets.

QDataStream::QDataStream(QByteArray *a, QIODeviceBase::OpenMode mode)

Crée un flux de données qui opère sur un tableau d'octets, a. L'mode décrit comment utiliser ce périphérique.

Vous pouvez également utiliser `QDataStream(const QByteArray &)` si vous souhaitez simplement lire à partir d'un tableau d'octets.

QByteArray n'étant pas une sous-classe de QIODevice, un objet QBuffer est créé en interne pour encapsuler le tableau d'octets.

[noexcept] QDataStream::~QDataStream()

Détruit le flux de données.

Le destructeur n'affectera pas le périphérique d'E/S actuel, sauf s'il s'agit d'un périphérique d'E/S interne (par exemple, un QBuffer) traitant une QByteArray transmise au constructeur, auquel cas le périphérique d'E/S interne est détruit.

void QDataStream::abortTransaction()

Annule une transaction de lecture.

Cette fonction est couramment utilisée pour annuler la transaction après des erreurs de protocole de niveau supérieur ou une perte de synchronisation du flux.

Si elle est appelée sur une transaction interne, l'annulation est déléguée à la transaction la plus externe, et les transactions internes lancées par la suite sont forcées d'échouer.

Pour la transaction la plus externe, supprime le point de restauration et toutes les données du flux dupliquées en interne. N’affecte pas la position de lecture actuelle du flux.

Définit l’état du flux de données sur

Voir également startTransaction(), commitTransaction() et rollbackTransaction().

bool QDataStream::atEnd() const

Renvoie ` true ` si le périphérique d'E/S a atteint la fin (fin du flux ou du fichier) ou si aucun périphérique d'E/S n'est défini ; sinon, renvoie ` false`.

Voir également QIODevice::atEnd().

QDataStream::ByteOrder QDataStream::byteOrder() const

Renvoie le paramètre d'ordre des octets actuel : soit « BigEndian », soit « LittleEndian ».

Voir également setByteOrder().

bool QDataStream::commitTransaction()

Termine une transaction de lecture. Renvoie ` true ` si aucune erreur de lecture ne s'est produite au cours de la transaction ; sinon, renvoie ` false`.

Si elle est appelée au sein d’une transaction interne, la validation sera reportée jusqu’à ce que l’appel le plus externe à `commitTransaction()`, ` rollbackTransaction()` ou ` abortTransaction()` ait lieu.

Sinon, si l’état du flux indique que la lecture a dépassé la fin des données, cette fonction rétablit les données du flux jusqu’au point de l’appel à startTransaction(). Lorsque cette situation se produit, vous devez attendre l’arrivée de nouvelles données, après quoi vous lancez une nouvelle transaction. Si le flux de données a lu des données corrompues ou si l’une des transactions internes a été interrompue, cette fonction interrompt la transaction.

Voir également startTransaction(), rollbackTransaction() et abortTransaction().

QIODevice *QDataStream::device() const

Renvoie le périphérique d'E/S actuellement défini, ou nullptr si aucun périphérique n'est défini.

Voir aussi setDevice().

QDataStream::FloatingPointPrecision QDataStream::floatingPointPrecision() const

Renvoie la précision en virgule flottante du flux de données.

Voir également FloatingPointPrecision et setFloatingPointPrecision().

[since 6.7] QDataStream &QDataStream::readBytes(char *&s, qint64 &l)

Lit le tampon s à partir du flux et renvoie une référence au flux.

Le tampon s est alloué à l'aide de new []. Détruisez-le à l'aide de l'opérateur delete [].

Le paramètre ` l ` est défini sur la longueur du tampon. Si la chaîne lue est vide, ` l ` est défini sur 0 et ` s ` est défini sur ` nullptr`.

Le format de sérialisation se compose d’abord d’un spécificateur de longueur, suivi de l octets de données. Le spécificateur de longueur est un quint32 si la version est inférieure à 6.7 ou si le nombre d’éléments est inférieur à 0xfffffffe (2^32 - 2) ; dans le cas contraire, il s’agit d’une valeur d’extension 0xfffffffe suivie d’un quint64 contenant la valeur réelle. De plus, pour les conteneurs prenant en charge isNull(), celui-ci est encodé sous la forme d’un seul quint32 dont tous les bits sont activés et ne contenant aucune donnée.

Cette fonction a été introduite dans Qt 6.7.

Voir également readRawData() et writeBytes().

qint64 QDataStream::readRawData(char *s, qint64 len)

Lit au maximum len octets depuis le flux dans s et renvoie le nombre d'octets lus. En cas d'erreur, cette fonction renvoie -1.

Le tampon s doit être préalloué. Les données ne sont pas décodées.

Voir également readBytes(), QIODevice::read() et writeRawData().

void QDataStream::resetStatus()

Réinitialise l'état du flux de données.

Voir également Status, status() et setStatus().

void QDataStream::rollbackTransaction()

Annule une transaction de lecture.

Cette fonction est couramment utilisée pour annuler la transaction lorsqu'une lecture incomplète a été détectée avant la validation de la transaction.

Si elle est appelée sur une transaction interne, l'annulation est déléguée à la transaction la plus externe, et les transactions internes lancées par la suite sont forcées d'échouer.

Pour la transaction la plus externe, restaure les données du flux jusqu’au point de l’appel à ` startTransaction()`. Si le flux de données a lu des données corrompues ou si l’une des transactions internes a été interrompue, cette fonction interrompt la transaction.

Si les opérations de flux précédentes ont abouti, définit l’état du flux de données sur

Voir également startTransaction(), commitTransaction() et abortTransaction().

void QDataStream::setByteOrder(QDataStream::ByteOrder bo)

Définit l'ordre des octets de sérialisation sur « bo ».

Le paramètre « bo » peut prendre les valeurs suivantes : « QDataStream::BigEndian » ou « QDataStream::LittleEndian ».

La valeur par défaut est « big-endian ». Nous vous recommandons de conserver ce paramètre, sauf si vous avez des besoins particuliers.

Voir également byteOrder().

void QDataStream::setDevice(QIODevice *d)

void QDataStream::setDevice(QIODevice * d)

Définit le périphérique d'E/S sur ` d`, qui peut être ` nullptr ` pour désactiver le périphérique d'E/S actuel.

Voir aussi device().

void QDataStream::setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision)

Définit la précision en virgule flottante du flux de données sur precision. Si la précision en virgule flottante est DoublePrecision et que la version du flux de données est Qt_4_6 ou supérieure, tous les nombres à virgule flottante seront écrits et lus avec une précision de 64 bits. Si la précision en virgule flottante est SinglePrecision et que la version est Qt_4_6 ou supérieure, tous les nombres à virgule flottante seront écrits et lus avec une précision de 32 bits.

Pour les versions antérieures à Qt_4_6, la précision des nombres à virgule flottante dans le flux de données dépend de l’opérateur de flux appelé.

La valeur par défaut est DoublePrecision.

Notez que cette propriété n’affecte pas la sérialisation ou la désérialisation des instances de ` qfloat16 `.

Voir aussi ` floatingPointPrecision()`.

void QDataStream::setStatus(QDataStream::Status status)

Définit l'état du flux de données sur l'status e spécifiée.

Les appels suivants à setStatus() sont ignorés jusqu’à ce que la fonction resetStatus() soit appelée.

Voir également Status, status() et resetStatus().

void QDataStream::setVersion(int v)

Définit le numéro de version du format de sérialisation des données sur « v », une valeur de l'énumération « Version ».

Vous n'avez pas besoin de définir de version si vous utilisez la version actuelle de Qt, mais nous vous recommandons de le faire pour vos propres formats binaires personnalisés ; voir Versioning dans la section « Description détaillée ».

Afin de prendre en charge de nouvelles fonctionnalités, le format de sérialisation en flux de données de certaines classes Qt a été modifié dans certaines versions de Qt. Si vous souhaitez lire des données créées par une version antérieure de Qt, ou écrire des données pouvant être lues par un programme compilé avec une version antérieure de Qt, utilisez cette fonction pour modifier le format de sérialisation utilisé par ` QDataStream`.

L'énumération ` Version ` fournit des constantes symboliques pour les différentes versions de Qt. Par exemple :

QDataStream out(&file);
out.setVersion(QDataStream::Qt_4_0);

Voir également ` version()` et ` Version`.

qint64 QDataStream::skipRawData(qint64 len)

Ignore len octets du périphérique. Renvoie le nombre d’octets effectivement ignorés, ou -1 en cas d’erreur.

Cela revient à appeler la fonction ` readRawData()` sur un tampon de longueur ` len ` et à ignorer le contenu de ce tampon.

Voir aussi QIODevice::seek().

void QDataStream::startTransaction()

Lance une nouvelle transaction de lecture sur le flux.

Définit un point de restauration au sein de la séquence d’opérations de lecture. Pour les périphériques séquentiels, les données lues seront dupliquées en interne afin de permettre la récupération en cas de lectures incomplètes. Pour les périphériques à accès aléatoire, cette fonction enregistre la position actuelle du flux. Appelez commitTransaction(), rollbackTransaction() ou abortTransaction() pour terminer la transaction en cours.

Une fois qu’une transaction est lancée, les appels suivants à cette fonction rendront la transaction récursive. Les transactions internes agissent en tant qu’agents de la transaction la plus externe (c’est-à-dire qu’elles signalent l’état des opérations de lecture à la transaction la plus externe, qui peut alors restaurer la position du flux).

Lorsqu’une erreur survient au cours d’une transaction (y compris l’échec d’une transaction imbriquée), la lecture à partir du flux de données est suspendue (toutes les opérations de lecture suivantes renvoient des valeurs vides ou nulles) et les transactions imbriquées suivantes sont forcées à échouer. Le lancement d’une nouvelle transaction la plus externe permet de sortir de cet état. Ce comportement rend inutile la vérification séparée de chaque opération de lecture.

Voir également commitTransaction(), rollbackTransaction() et abortTransaction().

QDataStream::Status QDataStream::status() const

Renvoie l'état du flux de données.

Voir également Status, setStatus() et resetStatus().

int QDataStream::version() const

Renvoie le numéro de version du format de sérialisation des données.

Voir également setVersion() et Version.

QDataStream &QDataStream::writeBytes(const char *s, qint64 len)

Écrit le spécificateur de longueur len et le tampon s dans le flux, puis renvoie une référence à ce dernier.

La valeur len est sérialisée sous la forme d’un quint32 et, éventuellement, d’un quint64, suivis de len octets provenant de s. Notez que les données ne sont pas encodées.

Voir également writeRawData() et readBytes().

qint64 QDataStream::writeRawData(const char *s, qint64 len)

Écrit len octets depuis s dans le flux. Renvoie le nombre d'octets effectivement écrits, ou -1 en cas d'erreur. Les données ne sont pas encodées.

Voir également writeBytes(), QIODevice::write() et readRawData().

[explicit noexcept, since 6.10] QDataStream::operator bool() const

Indique si ce flux ne présente aucune erreur (la fonction `status()` renvoie ` Ok`).

Cette fonction a été introduite dans Qt 6.10.

QDataStream &QDataStream::operator<<(qint8 i)

Écrit un octet signé, i, dans le flux et renvoie une référence au flux.

QDataStream &QDataStream::operator<<(bool i)

Écrit une valeur booléenne, i, dans le flux. Renvoie une référence au flux.

[since 6.0] QDataStream &QDataStream::operator<<(char16_t c)

Écrit un caractère, c, dans le flux. Renvoie une référence au flux

Cette fonction a été introduite dans Qt 6.0.

[since 6.0] QDataStream &QDataStream::operator<<(char32_t c)

Écrit un caractère, c, dans le flux. Renvoie une référence au flux

Cette fonction a été introduite dans Qt 6.0.

QDataStream &QDataStream::operator<<(const char *s)

Écrit la chaîne « s », terminée par «\0 », dans le flux et renvoie une référence à ce dernier.

La chaîne est sérialisée à l'aide de ` writeBytes()`.

Voir également writeBytes() et writeRawData().

QDataStream &QDataStream::operator<<(double f)

Écrit un nombre à virgule flottante, f, dans le flux en utilisant le format standard IEEE 754. Renvoie une référence au flux.

Voir aussi setFloatingPointPrecision().

QDataStream &QDataStream::operator<<(float f)

Écrit un nombre à virgule flottante, f, dans le flux en utilisant le format standard IEEE 754. Renvoie une référence au flux.

Voir également setFloatingPointPrecision().

QDataStream &QDataStream::operator<<(qint16 i)

Écrit un entier signé de 16 bits, i, dans le flux et renvoie une référence au flux.

QDataStream &QDataStream::operator<<(qint32 i)

Écrit un entier signé de 32 bits, i, dans le flux et renvoie une référence à ce flux.

QDataStream &QDataStream::operator<<(qint64 i)

Écrit un entier signé de 64 bits, i, dans le flux et renvoie une référence au flux.

QDataStream &QDataStream::operator<<(quint16 i)

Écrit un entier non signé de 16 bits, i, dans le flux et renvoie une référence à ce flux.

QDataStream &QDataStream::operator<<(quint32 i)

Écrit un entier non signé, i, dans le flux sous la forme d'un entier non signé de 32 bits (quint32). Renvoie une référence au flux.

QDataStream &QDataStream::operator<<(quint64 i)

Écrit un entier non signé de 64 bits, i, dans le flux et renvoie une référence à ce dernier.

QDataStream &QDataStream::operator<<(quint8 i)

Écrit un octet non signé, i, dans le flux et renvoie une référence au flux.

QDataStream &QDataStream::operator<<(std::nullptr_t ptr)

Simule l'écriture d'une chaîne de caractères std::nullptr_t, ptr, dans le flux et renvoie une référence à ce dernier. Cette fonction n'écrit en réalité rien dans le flux, car les valeurs de type std::nullptr_t sont stockées sous forme de 0 octet.

QDataStream &QDataStream::operator>>(bool &i)

Lit une valeur booléenne à partir du flux et la stocke dans ` i`. Renvoie une référence au flux.

QDataStream &QDataStream::operator>>(qint8 &i)

Lit un octet signé à partir du flux et le stocke dans ` i`, puis renvoie une référence au flux.

QDataStream &QDataStream::operator>>(char *&s)

Lit la chaîne « s » à partir du flux et renvoie une référence à ce flux.

La chaîne est désérialisée à l’aide de ` readBytes() `, où le format de sérialisation est constitué d’abord d’un spécificateur de longueur ` quint32 `, suivi d’autant d’octets de données. La chaîne résultante est toujours terminée par «\0 ».

L’espace nécessaire à la chaîne est alloué à l’aide de ` new [] ` ; l’appelant doit le détruire à l’aide de ` delete []`.

Voir également readBytes() et readRawData().

[since 6.0] QDataStream &QDataStream::operator>>(char16_t &c)

Lit un caractère de 16 bits provenant du flux et le stocke dans ` c `, puis renvoie une référence au flux.

Cette fonction a été introduite dans Qt 6.0.

[since 6.0] QDataStream &QDataStream::operator>>(char32_t &c)

Lit un caractère de 32 bits provenant du flux et le stocke dans l c, puis renvoie une référence au flux.

Cette fonction a été introduite dans Qt 6.0.

QDataStream &QDataStream::operator>>(double &f)

Lit un nombre à virgule flottante à partir du flux et le stocke dans ` f`, en utilisant le format standard IEEE 754. Renvoie une référence au flux.

Voir également ` setFloatingPointPrecision()`.

QDataStream &QDataStream::operator>>(float &f)

Lit un nombre à virgule flottante depuis le flux et le stocke dans ` f`, en utilisant le format standard IEEE 754. Renvoie une référence au flux.

Voir également ` setFloatingPointPrecision()`.

QDataStream &QDataStream::operator>>(qint16 &i)

Lit un entier signé de 16 bits à partir du flux et l'affecte à ` i`, puis renvoie une référence au flux.

QDataStream &QDataStream::operator>>(qint32 &i)

Lit un entier signé de 32 bits à partir du flux et l'affecte à ` i`, puis renvoie une référence au flux.

QDataStream &QDataStream::operator>>(qint64 &i)

Lit un entier signé de 64 bits à partir du flux et l'affecte à ` i`, puis renvoie une référence au flux.

QDataStream &QDataStream::operator>>(quint16 &i)

Lit un entier non signé de 16 bits depuis le flux dans ` i` et renvoie une référence au flux.

QDataStream &QDataStream::operator>>(quint32 &i)

Lit un entier non signé de 32 bits à partir du flux et le stocke dans ` i`, puis renvoie une référence au flux.

QDataStream &QDataStream::operator>>(quint64 &i)

Lit un entier non signé de 64 bits à partir du flux, dans ` i`, et renvoie une référence au flux.

QDataStream &QDataStream::operator>>(quint8 &i)

Lit un octet non signé depuis le flux et le stocke dans ` i`, puis renvoie une référence au flux.

QDataStream &QDataStream::operator>>(std::nullptr_t &ptr)

Simule la lecture d'un std::nullptr_t s à partir du flux dans ` ptr ` et renvoie une référence au flux. Cette fonction ne lit en réalité rien à partir du flux, car les valeurs de ` std::nullptr_t ` sont stockées sous forme de 0 octet.