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 |
- Lista de todos los miembros, incluidos los heredados
- Miembros obsoletos
- QDataStream es parte de Input/Output y Networking.
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) |
Relacionados No miembros
(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.
| Constante | Valor | Descripción |
|---|---|---|
QDataStream::BigEndian | QSysInfo::BigEndian | Byte más significativo primero (por defecto) |
QDataStream::LittleEndian | QSysInfo::LittleEndian | Primero 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.
| Constante | Valor | Descripción |
|---|---|---|
QDataStream::SinglePrecision | 0 | Todos los números en coma flotante del flujo de datos tienen una precisión de 32 bits. |
QDataStream::DoublePrecision | 1 | Todos 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.
| Constante | Valor | Descripción |
|---|---|---|
QDataStream::Ok | 0 | El flujo de datos está funcionando normalmente. |
QDataStream::ReadPastEnd | 1 | El flujo de datos ha leído más allá del final de los datos en el dispositivo subyacente. |
QDataStream::ReadCorruptData | 2 | El flujo de datos ha leído datos corruptos. |
QDataStream::WriteFailed | 3 | El flujo de datos no puede escribir en el dispositivo subyacente. |
QDataStream::SizeLimitExceeded (since Qt 6.7) | 4 | El 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.
| Constante | Valor |
|---|---|
QDataStream::Qt_1_0 | 1 |
QDataStream::Qt_2_0 | 2 |
QDataStream::Qt_2_1 | 3 |
QDataStream::Qt_3_0 | 4 |
QDataStream::Qt_3_1 | 5 |
QDataStream::Qt_3_3 | 6 |
QDataStream::Qt_4_0 | 7 |
QDataStream::Qt_4_1 | Qt_4_0 |
QDataStream::Qt_4_2 | 8 |
QDataStream::Qt_4_3 | 9 |
QDataStream::Qt_4_4 | 10 |
QDataStream::Qt_4_5 | 11 |
QDataStream::Qt_4_6 | 12 |
QDataStream::Qt_4_7 | Qt_4_6 |
QDataStream::Qt_4_8 | Qt_4_7 |
QDataStream::Qt_4_9 | Qt_4_8 |
QDataStream::Qt_5_0 | 13 |
QDataStream::Qt_5_1 | 14 |
QDataStream::Qt_5_2 | 15 |
QDataStream::Qt_5_3 | Qt_5_2 |
QDataStream::Qt_5_4 | 16 |
QDataStream::Qt_5_5 | Qt_5_4 |
QDataStream::Qt_5_6 | 17 |
QDataStream::Qt_5_7 | Qt_5_6 |
QDataStream::Qt_5_8 | Qt_5_7 |
QDataStream::Qt_5_9 | Qt_5_8 |
QDataStream::Qt_5_10 | Qt_5_9 |
QDataStream::Qt_5_11 | Qt_5_10 |
QDataStream::Qt_5_12 | 18 |
QDataStream::Qt_5_13 | 19 |
QDataStream::Qt_5_14 | Qt_5_13 |
QDataStream::Qt_5_15 | Qt_5_14 |
QDataStream::Qt_6_0 | 20 |
QDataStream::Qt_6_1 | Qt_6_0 |
QDataStream::Qt_6_2 | Qt_6_0 |
QDataStream::Qt_6_3 | Qt_6_0 |
QDataStream::Qt_6_4 | Qt_6_0 |
QDataStream::Qt_6_5 | Qt_6_0 |
QDataStream::Qt_6_6 | 21 |
QDataStream::Qt_6_7 | 22 |
QDataStream::Qt_6_8 | Qt_6_7 |
QDataStream::Qt_6_9 | Qt_6_7 |
QDataStream::Qt_6_10 | 23 |
QDataStream::Qt_6_11 | 24 |
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
| Constante | Descripció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
| Constante | Descripció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.