En esta página

QBuffer Class

La clase QBuffer proporciona una interfaz « QIODevice » para un « QByteArray ». Más información...

Encabezado: #include <QBuffer>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Heredado de: QIODevice

Nota: Todas las funciones de esta clase son reentrantes.

Funciones públicas

QBuffer(QObject *parent = nullptr)
QBuffer(QByteArray *byteArray, QObject *parent = nullptr)
virtual ~QBuffer()
QByteArray &buffer()
const QByteArray &buffer() const
const QByteArray &data() const
void setBuffer(QByteArray *byteArray)
void setData(const QByteArray &data)
void setData(const char *data, qsizetype size)

Funciones públicas reimplementadas

virtual bool atEnd() const override
virtual bool canReadLine() const override
virtual void close() override
virtual bool open(QIODeviceBase::OpenMode mode) override
virtual qint64 pos() const override
virtual bool seek(qint64 pos) override
virtual qint64 size() const override

Funciones protegidas reimplementadas

virtual qint64 readData(char *data, qint64 len) override
virtual qint64 writeData(const char *data, qint64 len) override

Descripción detallada

QBuffer te permite acceder a un « QByteArray » mediante la interfaz « QIODevice ». El « QByteArray » se trata como un archivo estándar de acceso aleatorio. Ejemplo:

    QBuffer buffer;
    char ch;

    buffer.open(QBuffer::ReadWrite);
    buffer.write("Qt rocks!");
    buffer.seek(0);
    buffer.getChar(&ch);  // ch == 'Q'
    buffer.getChar(&ch);  // ch == 't'
    buffer.getChar(&ch);  // ch == ' '
    buffer.getChar(&ch);  // ch == 'r'

De forma predeterminada, al crear un QBuffer se genera automáticamente un búfer interno de « QByteArray ». Puedes acceder a este búfer directamente llamando a ` buffer()`. También puedes utilizar QBuffer con un « QByteArray » ya existente llamando a ` setBuffer()` o pasando tu matriz al constructor de QBuffer.

Llama a ` open()` para abrir el búfer. A continuación, llama a ` write()` o a ` putChar()` para escribir en el búfer, y a ` read()`, ` readLine()`, ` readAll()` o ` getChar()` para leer de él. ` size()` devuelve el tamaño actual del búfer, y puedes desplazarte a posiciones arbitrarias en el búfer llamando a ` seek()`. Cuando hayas terminado de acceder al búfer, llama a close().

El siguiente fragmento de código muestra cómo escribir datos en un QByteArray utilizando QDataStream y QBuffer:

    QByteArray byteArray;
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);

    QDataStream out(&buffer);
    out << palette;

En la práctica, convertimos el ` QPalette ` de la aplicación en una matriz de bytes. A continuación se explica cómo leer los datos del ` QByteArray`:

    QPalette palette;
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::ReadOnly);

    QDataStream in(&buffer);
    in >> palette;

QTextStream Además, ` QDataStream ` proporciona constructores prácticos que aceptan un ` QByteArray ` y crean un `QBuffer` en segundo plano.

QBuffer emite la señal readyRead() cuando llegan nuevos datos al búfer. Al conectarse a esta señal, puedes utilizar QBuffer para almacenar datos temporales antes de procesarlos. QBuffer también emite la señal bytesWritten() cada vez que se escriben nuevos datos en el búfer.

Véase también QFile, QDataStream, QTextStream y QByteArray.

Documentación de funciones miembro

[explicit] QBuffer::QBuffer(QObject *parent = nullptr)

Crea un búfer vacío con el ` parent` indicado. Puedes llamar a ` setData()` para rellenar el búfer con datos, o bien abrirlo en modo de escritura y utilizar ` write()`.

Véase también open().

QBuffer::QBuffer(QByteArray *byteArray, QObject *parent = nullptr)

Crea un QBuffer que utiliza el QByteArray al que apunta byteArray como búfer interno, y con el parent especificado. El autor de la llamada es responsable de garantizar que byteArray siga siendo válido hasta que se destruya el QBuffer o hasta que se llame a setBuffer() para cambiar el búfer. QBuffer no asume la propiedad del QByteArray.

Si se abre el búfer en modo de solo escritura o en modo de lectura y escritura y se escribe algo en el QBuffer, se modificará el byteArray.

Ejemplo:

    QByteArray byteArray("abc");
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);
    buffer.seek(3);
    buffer.write("def", 3);
    buffer.close();
    // byteArray == "abcdef"

Véase también open(), setBuffer() y setData().

[virtual noexcept] QBuffer::~QBuffer()

Elimina el búfer.

[override virtual] bool QBuffer::atEnd() const

Reimplementa: ` QIODevice::atEnd()` const.

QByteArray &QBuffer::buffer()

Devuelve una referencia al búfer interno de QBuffer. Puedes utilizarla para modificar QByteArray sin que QBuffer se entere.

Véase también setBuffer() y data().

const QByteArray &QBuffer::buffer() const

Esto es lo mismo que data().

Se trata de una función sobrecargada.

[override virtual] bool QBuffer::canReadLine() const

Reimplementa: ` QIODevice::canReadLine()` const.

[override virtual] void QBuffer::close()

Reimplementa: QIODevice::close().

const QByteArray &QBuffer::data() const

Devuelve los datos contenidos en el búfer.

Es lo mismo que buffer().

Véanse también setData() y setBuffer().

[override virtual] bool QBuffer::open(QIODeviceBase::OpenMode mode)

Reimplementa: QIODevice::open(modo OpenMode de QIODeviceBase).

Abre el búfer utilizando los indicadores de « mode » y devuelve « true » si la operación se realiza correctamente; en caso contrario, devuelve « false ».

Los indicadores para mode deben incluir QIODeviceBase::ReadOnly, WriteOnly o ReadWrite. De no ser así, se muestra un mensaje de error y el método falla. En cualquier otro caso, se ejecuta correctamente.

A diferencia de ` QFile::open()`, al abrir un ` QBuffer ` con ` WriteOnly ` no se trunca. Sin embargo, ` pos()` está configurado en ` 0`. Utiliza ` Append ` o ` Truncate ` para cambiar cualquiera de estos comportamientos.

[override virtual] qint64 QBuffer::pos() const

Reimplementa: ` QIODevice::pos()` const.

[override virtual protected] qint64 QBuffer::readData(char *data, qint64 len)

Reimplementa: QIODevice::readData(char *data, qint64 maxSize).

[override virtual] bool QBuffer::seek(qint64 pos)

Reimplementa: QIODevice::seek(qint64 pos).

void QBuffer::setBuffer(QByteArray *byteArray)

Hace que ` QBuffer ` utilice el ` QByteArray ` al que apunta ` byteArray ` como su búfer interno. La función que lo invoca es responsable de garantizar que ` byteArray ` siga siendo válido hasta que se destruya ` QBuffer `, o hasta que se llame a `setBuffer()` para cambiar el búfer. ` QBuffer ` no asume la propiedad de ` QByteArray`.

No realiza ninguna acción si isOpen() es verdadero.

Si abres el búfer en modo de solo escritura o en modo de lectura y escritura y escribes algo en QBuffer, se modificará byteArray.

Ejemplo:

    QByteArray byteArray("abc");
    QBuffer buffer;
    buffer.setBuffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);
    buffer.seek(3);
    buffer.write("def", 3);
    buffer.close();
    // byteArray == "abcdef"

Si byteArray es nullptr, el búfer crea su propio QByteArray interno sobre el que trabajar. Este array de bytes está inicialmente vacío.

Véase también buffer(), setData() y open().

void QBuffer::setData(const QByteArray &data)

Establece el contenido del búfer interno en « data ». Esto equivale a asignar « data » a « buffer()».

No realiza ninguna acción si isOpen() es verdadero.

Véanse también data() y setBuffer().

void QBuffer::setData(const char *data, qsizetype size)

Establece el contenido del búfer interno de modo que corresponda a los primeros size bytes de data.

Nota: En las versiones de Qt anteriores a la 6.5, esta función tomaba la longitud como parámetro « int », lo que podía provocar el truncamiento de los tamaños.

Esta es una función sobrecargada.

[override virtual] qint64 QBuffer::size() const

Reimplementa: ` QIODevice::size()` const.

[override virtual protected] qint64 QBuffer::writeData(const char *data, qint64 len)

Reimplementa: QIODevice::writeData(const char *data, qint64 maxSize).

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