Back to Qt.io
Contact Us Blog Download Qt
En esta página

QBuffer Class

La clase QBuffer proporciona una interfaz QIODevice para un QByteArray. Más...

Cabecera: #include <QBuffer>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Hereda: 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 permite acceder a un QByteArray utilizando la interfaz QIODevice. El QByteArray se trata como un fichero 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'

Por defecto, se crea un buffer interno QByteArray cuando se crea un QBuffer. Puedes acceder directamente a este búfer llamando a buffer(). También puede utilizar QBuffer con un QByteArray existente llamando a setBuffer(), o pasando su matriz al constructor de QBuffer.

Llama a open() para abrir el buffer. Luego llama a write() o putChar() para escribir en el buffer, y read(), readLine(), readAll(), o getChar() para leer de él. size() devuelve el tamaño actual del buffer, y puedes buscar posiciones arbitrarias en el buffer llamando a seek(). Cuando haya terminado de acceder a la memoria intermedia, llame 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;

Efectivamente, convertimos el QPalette de la aplicación en un array de bytes. A continuación se muestra cómo leer los datos de QByteArray:

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

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

QTextStream y QDataStream también proporcionan constructores de conveniencia que toman un QByteArray y que crean un QBuffer entre bastidores.

QBuffer emite readyRead() cuando llegan nuevos datos al buffer. Conectándote a esta señal, puedes utilizar QBuffer para almacenar datos temporales antes de procesarlos. QBuffer también emite bytesWritten() cada vez que se escriben nuevos datos en el buffer.

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

Documentación de las funciones miembro

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

Construye un búfer vacío con la dirección parent. Puedes llamar a setData() para llenar el buffer con datos, o puedes abrirlo en modo escritura y usar write().

Véase también open().

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

Construye un QBuffer que utiliza el QByteArray apuntado por byteArray como su buffer interno, y con el parent dado. El llamador es responsable de asegurar que byteArray permanezca válido hasta que el QBuffer sea destruido, o hasta que setBuffer() sea llamado para cambiar el buffer. QBuffer no se apropia de QByteArray.

Si abres el buffer en modo sólo escritura o en modo lectura-escritura y escribes algo en el QBuffer, byteArray se modificará.

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()

Destruye 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. Puede utilizarlo para modificar QByteArray a espaldas de QBuffer.

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

const QByteArray &QBuffer::buffer() const

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éase también setData() y setBuffer().

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

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

Abre el buffer usando mode flags, devolviendo true si tiene éxito; en caso contrario devuelve false.

Las banderas para mode deben incluir QIODeviceBase::ReadOnly, WriteOnly, o ReadWrite. Si no, se imprime un error y el método falla. En cualquier otro caso, tiene éxito.

A diferencia de QFile::open(), abrir un QBuffer con WriteOnly no lo trunca. Sin embargo, pos() se establece en 0. Utilice Append o Truncate para cambiar cualquiera de los dos 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 apuntado por byteArray como su buffer interno. El invocador es responsable de asegurar que byteArray permanezca válido hasta que QBuffer sea destruido, o hasta que se llame a setBuffer() para cambiar el buffer. QBuffer no se apropia de QByteArray.

No hace nada si isOpen() es verdadero.

Si se abre el buffer en modo sólo escritura o en modo lectura-escritura y se escribe algo en QBuffer, byteArray se modificará.

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 buffer crea su propio QByteArray interno sobre el que trabajar. Esta matriz de bytes está inicialmente vacía.

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

void QBuffer::setData(const QByteArray &data)

Establece que el contenido del búfer interno sea data. Esto es lo mismo que asignar data a buffer().

No hace nada si isOpen() es verdadero.

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

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

Establece el contenido del buffer interno para que sean los primeros size bytes de data.

Nota: En versiones de Qt anteriores a la 6.5, esta función tomaba la longitud como un parámetro int, truncando potencialmente 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.