|  | Home · Overviews · Examples |

# QBuffer Class Reference
[com.trolltech.qt.core module]

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

Inherits `QIODevice`.

## Detailed Description

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

`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. For example, you can pass the buffer to `QFtp` when downloading a file from an FTP server. Whenever a new payload of data has been downloaded, `readyRead` is emitted, and you can process the data that just arrived. `QBuffer` also emits `bytesWritten` every time new data has been written to the buffer.

See also `QFile`, `QDataStream`, `QTextStream`, and `QByteArray`.