En esta página

QDataStream Class

La clase QDataStream proporciona la serialización de datos binarios a un QIODevice. Más...

Cabecera: #include <QDataStream>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Hereda: QIODeviceBase

Nota: Todas las funciones de esta clase son reentrantes.

Tipos Públicos

enum ByteOrder { BigEndian, LittleEndian }
enum FloatingPointPrecision { SinglePrecision, DoublePrecision }
enum Status { Ok, ReadPastEnd, ReadCorruptData, WriteFailed, SizeLimitExceeded }
enum Version { Qt_1_0, Qt_2_0, Qt_2_1, Qt_3_0, Qt_3_1, …, Qt_6_11 }

Funciones públicas

QDataStream()
QDataStream(QIODevice *d)
QDataStream(const QByteArray &a)
QDataStream(QByteArray *a, QIODeviceBase::OpenMode mode)
~QDataStream()
void abortTransaction()
bool atEnd() const
QDataStream::ByteOrder byteOrder() const
bool commitTransaction()
QIODevice *device() const
QDataStream::FloatingPointPrecision floatingPointPrecision() const
(since 6.7) QDataStream &readBytes(char *&s, qint64 &l)
qint64 readRawData(char *s, qint64 len)
void resetStatus()
void rollbackTransaction()
void setByteOrder(QDataStream::ByteOrder bo)
void setDevice(QIODevice *d)
void setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision)
void setStatus(QDataStream::Status status)
void setVersion(int v)
qint64 skipRawData(qint64 len)
void startTransaction()
QDataStream::Status status() const
int version() const
QDataStream &writeBytes(const char *s, qint64 len)
qint64 writeRawData(const char *s, qint64 len)
(since 6.10) operator bool() const
QDataStream &operator<<(qint8 i)
QDataStream &operator<<(bool i)
(since 6.0) QDataStream &operator<<(char16_t c)
(since 6.0) QDataStream &operator<<(char32_t c)
QDataStream &operator<<(const char *s)
QDataStream &operator<<(double f)
QDataStream &operator<<(float f)
QDataStream &operator<<(qint16 i)
QDataStream &operator<<(qint32 i)
QDataStream &operator<<(qint64 i)
QDataStream &operator<<(quint16 i)
QDataStream &operator<<(quint32 i)
QDataStream &operator<<(quint64 i)
QDataStream &operator<<(quint8 i)
QDataStream &operator<<(std::nullptr_t ptr)
QDataStream &operator>>(bool &i)
QDataStream &operator>>(qint8 &i)
QDataStream &operator>>(char *&s)
(since 6.0) QDataStream &operator>>(char16_t &c)
(since 6.0) QDataStream &operator>>(char32_t &c)
QDataStream &operator>>(double &f)
QDataStream &operator>>(float &f)
QDataStream &operator>>(qint16 &i)
QDataStream &operator>>(qint32 &i)
QDataStream &operator>>(qint64 &i)
QDataStream &operator>>(quint16 &i)
QDataStream &operator>>(quint32 &i)
QDataStream &operator>>(quint64 &i)
QDataStream &operator>>(quint8 &i)
QDataStream &operator>>(std::nullptr_t &ptr)
(since 6.0) QDataStream &operator<<(QDataStream &out, const std::pair<T1, T2> &pair)
(since 6.0) QDataStream &operator>>(QDataStream &in, std::pair<T1, T2> &pair)

Descripción detallada

Un flujo de datos es un flujo binario de información codificada que es 100% independiente del sistema operativo del ordenador anfitrión, de la CPU o del orden de los bytes. Por ejemplo, un flujo de datos escrito por un PC con Windows puede ser leído por un Sun SPARC con Solaris.

También puede utilizar un flujo de datos para leer/escribir raw unencoded binary data. Si desea un flujo de entrada de "análisis sintáctico", consulte QTextStream.

La clase QDataStream implementa la serialización de los tipos de datos básicos de C++, como char, short, int, char *, etc. La serialización de datos más complejos se realiza dividiendo los datos en unidades primitivas.

Un flujo de datos coopera estrechamente con un QIODevice. Un QIODevice representa un medio de entrada/salida del que se pueden leer y escribir datos. La clase QFile es un ejemplo de dispositivo de E/S.

Ejemplo (escribir datos binarios en un flujo):

QFile file("file.dat");
file.open(QIODevice::WriteOnly);
QDataStream out(&file);   // we will serialize the data into the file
out << QString("the answer is");   // serialize a string
out << (qint32)42;        // serialize an integer

Ejemplo (leer datos binarios de un flujo):

QFile file("file.dat");
file.open(QIODevice::ReadOnly);
QDataStream in(&file);    // read the data serialized from the file
QString str;
qint32 a;
in >> str >> a;           // extract "the answer is" and 42

Cada elemento escrito en el flujo se escribe en un formato binario predefinido que varía en función del tipo de elemento. Los tipos Qt soportados incluyen QBrush, QColor, QDateTime, QFont, QPixmap, QString, QVariant y muchos otros. Para la lista completa de todos los tipos Qt que soportan el flujo de datos ver Serializing Qt Data Types.

En el caso de los enteros, lo mejor es siempre convertirlos a un tipo entero de Qt para escribirlos, y volver a leerlos en el mismo tipo entero de Qt. Esto asegura que obtendrá enteros del tamaño que desea y le aísla de las diferencias entre compiladores y plataformas.

Las enumeraciones pueden serializarse a través de QDataStream sin necesidad de definir manualmente operadores de transmisión. Las clases Enum se serializan utilizando el tamaño declarado.

El dispositivo de E/S inicial se establece normalmente en el constructor, pero puede cambiarse con setDevice(). Si se ha llegado al final de los datos (o si no hay ningún dispositivo de E/S establecido) atEnd() devolverá true.

Serialización de contenedores y cadenas

El formato de serialización es primero un especificador de longitud, luego l bytes de datos. El especificador de longitud es un quint32 si la versión es inferior a 6.7 o si el número de elementos es inferior a 0xfffffffe (2^32 -2). En caso contrario hay un valor de extensión 0xfffffffe seguido de un quint64 con el valor real. Además, para los contenedores que soportan isNull(), se codifica como un único quint32 con todos los bits establecidos y sin datos.

Por poner un ejemplo, si el tamaño de la cadena cabe en 32 bits, una cadena char * se escribe como un entero de 32 bits igual a la longitud de la cadena, incluido el byte '\0', seguido de todos los caracteres de la cadena, incluido el byte '\0'. Si el tamaño de la cadena es mayor, se escribe el valor 0xffffffffe como marcador de un tamaño ampliado, seguido de 64 bits del tamaño real. Cuando se lee una cadena char *, primero se leen 4 bytes. Si el valor no es igual a 0xffffffffe (el marcador de tamaño extendido), entonces estos 4 bytes se tratan como el tamaño de 32 bits de la cadena. En caso contrario, se leen los 8 bytes siguientes y se tratan como el tamaño de 64 bits de la cadena. A continuación, se leen todos los caracteres de la cadena char *, incluido el terminador '\0'.

Versionado

El formato binario de QDataStream ha evolucionado desde Qt 1.0, y es probable que continúe evolucionando para reflejar los cambios realizados en Qt. Cuando se introducen o envían tipos complejos, es muy importante asegurarse de que se utiliza la misma versión del flujo (version()) para leer y escribir. Si necesitas compatibilidad hacia adelante y hacia atrás, puedes codificar el número de versión en la aplicación:

stream.setVersion(QDataStream::Qt_4_0);

Si estás produciendo un nuevo formato de datos binarios, como un formato de archivo para documentos creados por tu aplicación, podrías usar un QDataStream para escribir los datos en un formato portable. Típicamente, escribirías una breve cabecera conteniendo una cadena mágica y un número de versión para darte espacio para futuras expansiones. Por ejemplo:

QFile file("file.xxx");
file.open(QIODevice::WriteOnly);
QDataStream out(&file);

// Write a header with a "magic number" and a version
out << (quint32)0xA0B0C0D0;
out << (qint32)123;

out.setVersion(QDataStream::Qt_4_0);

// Write the data
out << lots_of_interesting_data;

Luego léelo con:

QFile file("file.xxx");
file.open(QIODevice::ReadOnly);
QDataStream in(&file);

// Read and check the header
quint32 magic;
in >> magic;
if (magic != 0xA0B0C0D0)
    return XXX_BAD_FILE_FORMAT;

// Read the version
qint32 version;
in >> version;
if (version < 100)
    return XXX_BAD_FILE_TOO_OLD;
if (version > 123)
    return XXX_BAD_FILE_TOO_NEW;

if (version <= 110)
    in.setVersion(QDataStream::Qt_3_1);
else
    in.setVersion(QDataStream::Qt_4_0);

// Read the data
in >> lots_of_interesting_data;
if (version >= 120)
    in >> data_new_in_XXX_version_1_2;
in >> other_interesting_data;

Puede seleccionar qué orden de bytes utilizar al serializar los datos. La configuración por defecto es big-endian (MSB primero). Cambiarlo a little-endian rompe la portabilidad (a menos que el lector también cambie a little-endian). Recomendamos mantener esta configuración a menos que tenga requisitos especiales.

Lectura y escritura de datos binarios sin procesar

Es posible que desee leer/escribir sus propios datos binarios sin procesar a/desde el flujo de datos directamente. Los datos pueden leerse desde el flujo a un char * preasignado utilizando readRawData(). Del mismo modo, los datos pueden escribirse en el flujo utilizando writeRawData(). Ten en cuenta que cualquier codificación/decodificación de los datos debe ser realizada por ti.

Un par de funciones similares son readBytes() y writeBytes(). Se diferencian de sus homólogas en bruto en lo siguiente: readBytes() lee un quint32 que se toma como la longitud de los datos a leer, entonces ese número de bytes se lee en el preasignado char *; writeBytes() escribe un quint32 que contiene la longitud de los datos, seguido de los datos. Ten en cuenta que cualquier codificación/decodificación de los datos (aparte de la longitud quint32) debe ser realizada por ti.

Lectura y Escritura de Clases de Colección Qt

Las clases contenedoras de Qt también pueden serializarse a un QDataStream. Estas incluyen QList, QSet, QHash, y QMap. Los operadores de flujo se declaran como no miembros de las clases.

Leyendo y Escribiendo Otras Clases Qt

Además de los operadores de flujo sobrecargados documentados aquí, cualquier clase Qt que quieras serializar a un QDataStream tendrá operadores de flujo apropiados declarados como no-miembros de la clase:

QDataStream &operator<<(QDataStream &, const QXxx &);
QDataStream &operator>>(QDataStream &, QXxx &);

Por ejemplo, aquí están los operadores de flujo declarados como no-miembros de la clase QImage:

QDataStream &operator<<(QDataStream &stream, const QImage &image);
QDataStream &operator>>(QDataStream &stream, QImage &image);

Para ver si su clase Qt favorita tiene definidos operadores de flujo similares, consulte la sección Related Non-Members de la página de documentación de la clase.

Uso de Transacciones de Lectura

Cuando un flujo de datos opera en un dispositivo asíncrono, los trozos de datos pueden llegar en puntos arbitrarios en el tiempo. La clase QDataStream implementa un mecanismo de transacción que proporciona la capacidad de leer los datos atómicamente con una serie de operadores de flujo. Como ejemplo, puedes manejar lecturas incompletas desde un socket usando una transacción en una ranura conectada a la señal readyRead():

in.startTransaction();
QString str;
qint32 a;
in >> str >> a; // try to read packet atomically

if (!in.commitTransaction())
    return;     // wait for more data

Si no se recibe ningún paquete completo, este código restaura el flujo a la posición inicial, tras lo cual hay que esperar a que lleguen más datos.

Corrupción y Seguridad

QDataStream no es resistente contra entradas de datos corruptas y por lo tanto no debería ser usado para situaciones sensibles a la seguridad, incluso cuando se usan transacciones. Las transacciones ayudarán a determinar si una entrada válida puede ser decodificada con los datos actualmente disponibles en un dispositivo asíncrono, pero asumirán que los datos que están disponibles están correctamente formados.

Adicionalmente, muchos operadores QDataStream demarshalling asignarán memoria basándose en la información encontrada en el stream. Esos operadores no realizan ninguna verificación sobre si la cantidad de memoria solicitada es razonable o si es compatible con la cantidad de datos disponibles en el stream (ejemplo: demarshalling un QByteArray o QString puede ver la solicitud de asignación de varios gigabytes de datos).

QDataStream no debe utilizarse en contenidos en cuya procedencia no se pueda confiar. Las aplicaciones deberían estar diseñadas para intentar decodificar sólo flujos cuya procedencia sea al menos tan fiable como la de la propia aplicación o sus plugins.

Véase también QTextStream y QVariant.

Documentación de tipos de miembros

enum QDataStream::ByteOrder

El orden de bytes utilizado para leer/escribir los datos.

ConstanteValorDescripción
QDataStream::BigEndianQSysInfo::BigEndianByte más significativo primero (por defecto)
QDataStream::LittleEndianQSysInfo::LittleEndianPrimero el byte menos significativo

enum QDataStream::FloatingPointPrecision

La precisión de los números en coma flotante utilizados para leer/escribir los datos. Esto sólo tendrá efecto si la versión del flujo de datos es Qt_4_6 o superior.

Atención: La precisión en coma flotante debe tener el mismo valor en el objeto que escribe y en el que lee el flujo de datos.

ConstanteValorDescripción
QDataStream::SinglePrecision0Todos los números en coma flotante del flujo de datos tienen una precisión de 32 bits.
QDataStream::DoublePrecision1Todos los números en coma flotante del flujo de datos tienen una precisión de 64 bits.

Véase también setFloatingPointPrecision() y floatingPointPrecision().

enum QDataStream::Status

Este enum describe el estado actual del flujo de datos.

ConstanteValorDescripción
QDataStream::Ok0El flujo de datos está funcionando normalmente.
QDataStream::ReadPastEnd1El flujo de datos ha leído más allá del final de los datos en el dispositivo subyacente.
QDataStream::ReadCorruptData2El flujo de datos ha leído datos corruptos.
QDataStream::WriteFailed3El flujo de datos no puede escribir en el dispositivo subyacente.
QDataStream::SizeLimitExceeded (since Qt 6.7)4El flujo de datos no puede leer o escribir los datos porque su tamaño es superior al soportado por la plataforma actual. Esto puede ocurrir, por ejemplo, cuando se intenta leer más de 2 GiB de datos en una plataforma de 32 bits.

enum QDataStream::Version

Este enum proporciona sinónimos simbólicos para los números de versión del formato de serialización de datos.

ConstanteValor
QDataStream::Qt_1_01
QDataStream::Qt_2_02
QDataStream::Qt_2_13
QDataStream::Qt_3_04
QDataStream::Qt_3_15
QDataStream::Qt_3_36
QDataStream::Qt_4_07
QDataStream::Qt_4_1Qt_4_0
QDataStream::Qt_4_28
QDataStream::Qt_4_39
QDataStream::Qt_4_410
QDataStream::Qt_4_511
QDataStream::Qt_4_612
QDataStream::Qt_4_7Qt_4_6
QDataStream::Qt_4_8Qt_4_7
QDataStream::Qt_4_9Qt_4_8
QDataStream::Qt_5_013
QDataStream::Qt_5_114
QDataStream::Qt_5_215
QDataStream::Qt_5_3Qt_5_2
QDataStream::Qt_5_416
QDataStream::Qt_5_5Qt_5_4
QDataStream::Qt_5_617
QDataStream::Qt_5_7Qt_5_6
QDataStream::Qt_5_8Qt_5_7
QDataStream::Qt_5_9Qt_5_8
QDataStream::Qt_5_10Qt_5_9
QDataStream::Qt_5_11Qt_5_10
QDataStream::Qt_5_1218
QDataStream::Qt_5_1319
QDataStream::Qt_5_14Qt_5_13
QDataStream::Qt_5_15Qt_5_14
QDataStream::Qt_6_020
QDataStream::Qt_6_1Qt_6_0
QDataStream::Qt_6_2Qt_6_0
QDataStream::Qt_6_3Qt_6_0
QDataStream::Qt_6_4Qt_6_0
QDataStream::Qt_6_5Qt_6_0
QDataStream::Qt_6_621
QDataStream::Qt_6_722
QDataStream::Qt_6_8Qt_6_7
QDataStream::Qt_6_9Qt_6_7
QDataStream::Qt_6_1023
QDataStream::Qt_6_1124

Véase también setVersion() y version().

Documentación de las funciones miembro

QDataStream::QDataStream()

Construye un flujo de datos que no tiene dispositivo de E/S.

Véase también setDevice().

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

Construye un flujo de datos que utiliza el dispositivo de E/S d.

Véase también setDevice() y device().

QDataStream::QDataStream(const QByteArray &a)

Construye un flujo de datos de sólo lectura que opera sobre la matriz de bytes a. Usa QDataStream(QByteArray*, int) si quieres escribir en un array de bytes.

Dado que QByteArray no es una subclase de QIODevice, internamente se crea una QBuffer para envolver el array de bytes.

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

Construye un flujo de datos que opera sobre una matriz de bytes, a. En mode se describe cómo se va a utilizar el dispositivo.

Alternativamente, puedes usar QDataStream(const QByteArray &) si solo quieres leer de un array de bytes.

Dado que QByteArray no es una subclase de QIODevice, internamente se crea una QBuffer para envolver el array de bytes.

[noexcept] QDataStream::~QDataStream()

Destruye el flujo de datos.

El destructor no afectará al dispositivo de E/S actual, a menos que sea un dispositivo de E/S interno (por ejemplo, un QBuffer) procesando un QByteArray pasado en el constructor, en cuyo caso el dispositivo de E/S interno es destruido.

void QDataStream::abortTransaction()

Aborta una transacción de lectura.

Esta función se utiliza comúnmente para descartar la transacción después de errores de protocolo de nivel superior o pérdida de sincronización del flujo.

Si se llama en una transacción interna, el aborto se delega a la transacción más externa, y las transacciones internas iniciadas posteriormente son forzadas a fallar.

Para la transacción más externa, descarta el punto de restauración y cualquier dato duplicado internamente del flujo. No afectará a la posición de lectura actual del flujo.

Establece el estado del flujo de datos a

ConstanteDescripción
ReadCorruptData.

Véase también startTransaction(), commitTransaction(), y rollbackTransaction().

bool QDataStream::atEnd() const

Devuelve true si el dispositivo de E/S ha alcanzado la posición final (final del flujo o archivo) o si no hay ningún dispositivo de E/S establecido; en caso contrario devuelve false.

Véase también QIODevice::atEnd().

QDataStream::ByteOrder QDataStream::byteOrder() const

Devuelve el orden actual de los bytes: BigEndian o LittleEndian.

Véase también setByteOrder().

bool QDataStream::commitTransaction()

Completa una transacción de lectura. Devuelve true si no se han producido errores de lectura durante la transacción; en caso contrario devuelve false.

Si se llama a una transacción interna, la confirmación se pospondrá hasta que se produzca la llamada externa a commitTransaction(), rollbackTransaction(), o abortTransaction().

De lo contrario, si el estado del flujo indica que se ha leído más allá del final de los datos, esta función restaura los datos del flujo al punto de la llamada a startTransaction(). Cuando se produce esta situación, es necesario esperar a que lleguen más datos, tras lo cual se inicia una nueva transacción. Si el flujo de datos ha leído datos corruptos o se ha abortado alguna de las transacciones internas, esta función aborta la transacción.

Véase también startTransaction(), rollbackTransaction(), y abortTransaction().

QIODevice *QDataStream::device() const

Devuelve el dispositivo de E/S configurado actualmente, o nullptr si no hay ningún dispositivo configurado.

Véase también setDevice().

QDataStream::FloatingPointPrecision QDataStream::floatingPointPrecision() const

Devuelve la precisión en coma flotante del flujo de datos.

Véase también FloatingPointPrecision y setFloatingPointPrecision().

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

Lee el búfer s del flujo y devuelve una referencia al flujo.

El búfer s se asigna utilizando new []. Se destruye con el operador delete [].

El parámetro l se establece en la longitud del búfer. Si la cadena leída está vacía, l se pone a 0 y s se pone a nullptr.

El formato de serialización es primero un especificador de longitud y luego l bytes de datos. El especificador de longitud es un quint32 si la versión es inferior a 6.7 o si el número de elementos es inferior a 0xfffffffe (2^32 -2), de lo contrario hay un valor de extensión 0xfffffffe seguido de un quint64 con el valor real. Además, para los contenedores que soportan isNull(), se codifica como un único quint32 con todos los bits establecidos y sin datos.

Esta función se introdujo en Qt 6.7.

Véase también readRawData() y writeBytes().

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

Lee como máximo len bytes del flujo en s y devuelve el número de bytes leídos. Si se produce un error, esta función devuelve -1.

El búfer s debe estar preasignado. Los datos no se descodifican.

Véase también readBytes(), QIODevice::read(), y writeRawData().

void QDataStream::resetStatus()

Restablece el estado del flujo de datos.

Véase también Status, status(), y setStatus().

void QDataStream::rollbackTransaction()

Revierte una transacción de lectura.

Esta función se utiliza normalmente para revertir la transacción cuando se detecta una lectura incompleta antes de confirmar la transacción.

Si se llama en una transacción interna, la reversión se delega a la transacción más externa, y las transacciones internas iniciadas posteriormente son forzadas a fallar.

Para la transacción más externa, restaura los datos del flujo al punto de la llamada a startTransaction(). Si el flujo de datos ha leído datos corruptos o alguna de las transacciones internas ha sido abortada, esta función aborta la transacción.

Si las operaciones de flujo anteriores tuvieron éxito, establece el estado del flujo de datos a

ConstanteDescripción
ReadPastEnd.

Véase también startTransaction(), commitTransaction(), y abortTransaction().

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

Establece el orden de los bytes de serialización en bo.

El parámetro bo puede ser QDataStream::BigEndian o QDataStream::LittleEndian.

La configuración por defecto es big-endian. Recomendamos dejar esta configuración a menos que tenga requisitos especiales.

Véase también byteOrder().

void QDataStream::setDevice(QIODevice *d)

void QDataStream::setDevice(QIODevice *d)

Establece el dispositivo de E/S a d, que puede ser nullptr para desestablecer el dispositivo de E/S actual.

Ver también device().

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

Establece la precisión en coma flotante del flujo de datos en precision. Si la precisión en coma flotante es DoublePrecision y la versión del flujo de datos es Qt_4_6 o superior, todos los números en coma flotante se escribirán y leerán con precisión de 64 bits. Si la precisión en coma flotante es SinglePrecision y la versión es Qt_4_6 o superior, todos los números en coma flotante se escribirán y leerán con precisión de 32 bits.

Para versiones anteriores a Qt_4_6, la precisión de los números en coma flotante en el flujo de datos depende del operador de flujo llamado.

El valor por defecto es DoublePrecision.

Tenga en cuenta que esta propiedad no afecta a la serialización o deserialización de las instancias de qfloat16.

Advertencia: Esta propiedad debe tener el mismo valor en el objeto que escribe y en el objeto que lee el flujo de datos.

Véase también floatingPointPrecision().

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

Establece el estado del flujo de datos en status.

Las llamadas posteriores a setStatus() se ignoran hasta que se llame a resetStatus().

Véase también Status, status(), y resetStatus().

void QDataStream::setVersion(int v)

Establece el número de versión del formato de serialización de datos a v, un valor del enum Version.

No tienes que establecer una versión si estás usando la versión actual de Qt, pero para tus propios formatos binarios personalizados te recomendamos que lo hagas; mira Versioning en la Descripción Detallada.

Para acomodar la nueva funcionalidad, el formato de serialización del flujo de datos de algunas clases Qt ha cambiado en algunas versiones de Qt. Si quieres leer datos que fueron creados por una versión anterior de Qt, o escribir datos que puedan ser leídos por un programa que fue compilado con una versión anterior de Qt, usa esta función para modificar el formato de serialización usado por QDataStream.

El enum Version proporciona constantes simbólicas para las diferentes versiones de Qt. Por ejemplo:

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

Ver también version() y Version.

qint64 QDataStream::skipRawData(qint64 len)

Omite len bytes del dispositivo. Devuelve el número de bytes realmente omitidos, o -1 en caso de error.

Esto equivale a llamar a readRawData() en un búfer de longitud len e ignorar el búfer.

Véase también QIODevice::seek().

void QDataStream::startTransaction()

Inicia una nueva transacción de lectura en el flujo.

Define un punto restaurable dentro de la secuencia de operaciones de lectura. Para dispositivos secuenciales, los datos leídos se duplicarán internamente para permitir la recuperación en caso de lecturas incompletas. Para dispositivos de acceso aleatorio, esta función guarda la posición actual del flujo. Llame a commitTransaction(), rollbackTransaction(), o abortTransaction() para finalizar la transacción actual.

Una vez iniciada una transacción, las llamadas posteriores a esta función harán que la transacción sea recursiva. Las transacciones internas actúan como agentes de la transacción externa (es decir, informan del estado de las operaciones de lectura a la transacción externa, que puede restaurar la posición del flujo).

Nota: No se admite la restauración al punto de la llamada anidada a startTransaction().

Cuando se produce un error durante una transacción (incluyendo el fallo de una transacción interna), la lectura del flujo de datos se suspende (todas las operaciones de lectura posteriores devuelven valores vacíos/cero) y las transacciones internas posteriores se ven forzadas a fallar. El inicio de una nueva transacción externa recupera este estado. Este comportamiento hace innecesario comprobar los errores de cada operación de lectura por separado.

Véase también commitTransaction(), rollbackTransaction(), y abortTransaction().

QDataStream::Status QDataStream::status() const

Devuelve el estado del flujo de datos.

Véase también Status, setStatus(), y resetStatus().

int QDataStream::version() const

Devuelve el número de versión del formato de serialización de datos.

Véase también setVersion() y Version.

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

Escribe el especificador de longitud len y el búfer s en el flujo y devuelve una referencia al flujo.

len se serializa como un quint32 y un quint64 opcional, seguido de len bytes de s. Tenga en cuenta que los datos no están codificados.

Véase también writeRawData() y readBytes().

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

Escribe len bytes desde s al flujo. Devuelve el número de bytes realmente escritos, o -1 en caso de error. Los datos no se codifican.

Véase también writeBytes(), QIODevice::write() y readRawData().

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

Devuelve si este flujo no tiene errores (status() devuelve Ok).

Esta función se introdujo en Qt 6.10.

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

Escribe un byte con signo, i, en el flujo y devuelve una referencia al flujo.

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

Escribe un valor booleano, i, en el flujo. Devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un carácter, c, en el flujo. Devuelve una referencia al flujo

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

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

Escribe un carácter, c, en el flujo. Devuelve una referencia al flujo

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

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

Escribe la cadena '\0'-terminada s en el flujo y devuelve una referencia al flujo.

La cadena se serializa utilizando writeBytes().

Esta es una función sobrecargada.

Véase también writeBytes() y writeRawData().

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

Escribe un número en coma flotante, f, en el flujo utilizando el formato estándar IEEE 754. Devuelve una referencia al flujo.

Esta es una función sobrecargada.

Véase también setFloatingPointPrecision().

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

Escribe un número en coma flotante, f, en el flujo utilizando el formato estándar IEEE 754. Devuelve una referencia al flujo.

Esta es una función sobrecargada.

Véase también setFloatingPointPrecision().

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

Escribe un entero de 16 bits con signo, i, en el flujo y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un entero de 32 bits con signo, i, en el flujo y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un entero de 64 bits con signo, i, en el flujo y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un entero de 16 bits sin signo, i, en el flujo y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un entero sin signo, i, en el flujo como un entero sin signo de 32 bits (quint32). Devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un entero de 64 bits sin signo, i, en el flujo y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Escribe un byte sin signo, i, en el flujo y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Simula la escritura de un std::nullptr_t, ptr, en el flujo y devuelve una referencia al flujo. En realidad, esta función no escribe nada en el flujo, ya que los valores de std::nullptr_t se almacenan como 0 bytes.

Se trata de una función sobrecargada.

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

Lee un valor booleano del flujo en i. Devuelve una referencia al flujo.

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

Lee un byte con signo del flujo en i, y devuelve una referencia al flujo.

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

Lee la cadena s del flujo y devuelve una referencia al flujo.

La cadena se deserializa utilizando readBytes(), donde el formato de serialización es un especificador de longitud quint32 en primer lugar, seguido de la misma cantidad de bytes de datos. La cadena resultante es siempre '\0'-terminada.

El espacio para la cadena se asigna utilizando new [] - la persona que llama debe destruirlo con delete [].

Se trata de una función sobrecargada.

Véase también readBytes() y readRawData().

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

Lee un carácter de 16 bits de ancho del flujo en c y devuelve una referencia al flujo.

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

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

Lee un carácter de 32 bits de ancho del flujo en c y devuelve una referencia al flujo.

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.0.

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

Lee un número en coma flotante del flujo en f, utilizando el formato estándar IEEE 754. Devuelve una referencia al flujo.

Esta es una función sobrecargada.

Véase también setFloatingPointPrecision().

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

Lee un número en coma flotante del flujo en f, utilizando el formato estándar IEEE 754. Devuelve una referencia al flujo.

Esta es una función sobrecargada.

Véase también setFloatingPointPrecision().

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

Lee un entero de 16 bits con signo del flujo en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Lee un entero de 32 bits con signo del flujo en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Lee un entero de 64 bits con signo del flujo en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Lee un entero de 16 bits sin signo del flujo en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Lee un entero de 32 bits sin signo del flujo en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Lee un entero de 64 bits sin signo del flujo, en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Lee un byte sin signo del flujo en i, y devuelve una referencia al flujo.

Se trata de una función sobrecargada.

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

Simula la lectura de un std::nullptr_t del flujo en ptr y devuelve una referencia al flujo. Esta función no lee realmente nada del flujo, ya que los valores de std::nullptr_t se almacenan como 0 bytes.

Se trata de una función sobrecargada.

No miembros relacionados

[since 6.0] template <typename T1, typename T2> QDataStream &operator<<(QDataStream &out, const std::pair<T1, T2> &pair)

Escribe el par pair en el flujo out.

Esta función requiere los tipos T1 y T2 para implementarse operator<<().

Esta función fue introducida en Qt 6.0.

Véase también Serializar tipos de datos Qt.

[since 6.0] template <typename T1, typename T2> QDataStream &operator>>(QDataStream &in, std::pair<T1, T2> &pair)

Lee un par del flujo in en pair.

Esta función requiere los tipos T1 y T2 para implementar operator>>().

Esta función se introdujo en Qt 6.0.

Véase también Serializar tipos de datos Qt.

© 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.