Back to Doc.qt.io
Contact Us Blog Download Qt

QBuffer Class

The QBuffer class provides a QIODevice interface for a QByteArray. More...

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

Note: All functions in this class are reentrant.

Public Functions

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)

Reimplemented Public Functions

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

Reimplemented Protected Functions

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

Detailed Description

QBuffer allows you to access a QByteArray using the QIODevice interface. The QByteArray is treated just as a standard random-accessed file. Example:

    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'

By default, an internal QByteArray buffer is created for you when you create a QBuffer. You can access this buffer directly by calling buffer(). You can also use QBuffer with an existing QByteArray by calling setBuffer(), or by passing your array to QBuffer's constructor.

Call open() to open the buffer. Then call write() or putChar() to write to the buffer, and read(), readLine(), readAll(), or getChar() to read from it. size() returns the current size of the buffer, and you can seek to arbitrary positions in the buffer by calling seek(). When you are done with accessing the buffer, call close().

The following code snippet shows how to write data to a QByteArray using QDataStream and QBuffer:

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

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

Effectively, we convert the application's QPalette into a byte array. Here's how to read the data from the QByteArray:

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

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

QTextStream and QDataStream also provide convenience constructors that take a QByteArray and that create a QBuffer behind the scenes.

QBuffer emits readyRead() when new data has arrived in the buffer. By connecting to this signal, you can use QBuffer to store temporary data before processing it. QBuffer also emits bytesWritten() every time new data has been written to the buffer.

See also QFile, QDataStream, QTextStream, and QByteArray.

Member Function Documentation

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

Constructs an empty buffer with the given parent. You can call setData() to fill the buffer with data, or you can open it in write mode and use write().

See also open().

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

Constructs a QBuffer that uses the QByteArray pointed to by byteArray as its internal buffer, and with the given parent. The caller is responsible for ensuring that byteArray remains valid until the QBuffer is destroyed, or until setBuffer() is called to change the buffer. QBuffer doesn't take ownership of the QByteArray.

If you open the buffer in write-only mode or read-write mode and write something into the QBuffer, byteArray will be modified.

Example:

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

See also open(), setBuffer(), and setData().

[virtual noexcept] QBuffer::~QBuffer()

Destroys the buffer.

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

Reimplements: QIODevice::atEnd() const.

QByteArray &QBuffer::buffer()

Returns a reference to the QBuffer's internal buffer. You can use it to modify the QByteArray behind the QBuffer's back.

See also setBuffer() and data().

const QByteArray &QBuffer::buffer() const

This is an overloaded function.

This is the same as data().

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

Reimplements: QIODevice::canReadLine() const.

[override virtual] void QBuffer::close()

Reimplements: QIODevice::close().

const QByteArray &QBuffer::data() const

Returns the data contained in the buffer.

This is the same as buffer().

See also setData() and setBuffer().

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

Reimplements: QIODevice::open(QIODeviceBase::OpenMode mode).

Opens the buffer using mode flags, returning true if successful; otherwise returns false.

The flags for mode must include QIODeviceBase::ReadOnly, WriteOnly, or ReadWrite. If not, an error is printed and the method fails. In any other case, it succeeds.

Unlike QFile::open(), opening a QBuffer with WriteOnly does not truncate it. However, pos() is set to 0. Use Append or Truncate to change either behavior.

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

Reimplements: QIODevice::pos() const.

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

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

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

Reimplements: QIODevice::seek(qint64 pos).

void QBuffer::setBuffer(QByteArray *byteArray)

Makes QBuffer use the QByteArray pointed to by byteArray as its internal buffer. The caller is responsible for ensuring that byteArray remains valid until the QBuffer is destroyed, or until setBuffer() is called to change the buffer. QBuffer doesn't take ownership of the QByteArray.

Does nothing if isOpen() is true.

If you open the buffer in write-only mode or read-write mode and write something into the QBuffer, byteArray will be modified.

Example:

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

If byteArray is nullptr, the buffer creates its own internal QByteArray to work on. This byte array is initially empty.

See also buffer(), setData(), and open().

void QBuffer::setData(const QByteArray &data)

Sets the contents of the internal buffer to be data. This is the same as assigning data to buffer().

Does nothing if isOpen() is true.

See also data() and setBuffer().

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

This is an overloaded function.

Sets the contents of the internal buffer to be the first size bytes of data.

Note: In Qt versions prior to 6.5, this function took the length as an int parameter, potentially truncating sizes.

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

Reimplements: QIODevice::size() const.

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

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

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