Back to Qt.io
Contact Us Blog Download Qt

QBuffer Class

Die Klasse QBuffer bietet eine QIODevice Schnittstelle für eine QByteArray. Mehr...

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

Hinweis: Alle Funktionen in dieser Klasse sind reentrant.

Öffentliche Funktionen

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)

Reimplementierte öffentliche Funktionen

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

Reimplementierte geschützte Funktionen

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

Detaillierte Beschreibung

QBuffer ermöglicht den Zugriff auf eine QByteArray über die Schnittstelle QIODevice. Die QByteArray wird wie eine Standarddatei mit wahlfreiem Zugriff behandelt. Beispiel:

    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'

Standardmäßig wird ein interner QByteArray Puffer für Sie erstellt, wenn Sie einen QBuffer erstellen. Sie können direkt auf diesen Puffer zugreifen, indem Sie buffer() aufrufen. Sie können QBuffer auch mit einem vorhandenen QByteArray verwenden, indem Sie setBuffer() aufrufen oder Ihr Array an den Konstruktor von QBuffer übergeben.

Rufen Sie open() auf, um den Puffer zu öffnen. Rufen Sie dann write() oder putChar() auf, um in den Puffer zu schreiben, und read(), readLine(), readAll() oder getChar(), um aus ihm zu lesen. size() gibt die aktuelle Größe des Puffers zurück, und Sie können beliebige Positionen im Puffer ansteuern, indem Sie seek() aufrufen. Wenn Sie mit dem Zugriff auf den Puffer fertig sind, rufen Sie close() auf.

Der folgende Codeschnipsel zeigt, wie man mit QDataStream und QBuffer Daten in einen QByteArray schreibt:

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

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

Wir konvertieren die QPalette der Anwendung in ein Byte-Array. Hier wird gezeigt, wie die Daten aus dem QByteArray gelesen werden:

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

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

QTextStream und QDataStream bieten auch Convenience-Konstruktoren, die einen QByteArray annehmen und im Hintergrund einen QBuffer erzeugen.

QBuffer gibt readyRead() aus, wenn neue Daten im Puffer angekommen sind. Indem Sie sich mit diesem Signal verbinden, können Sie QBuffer verwenden, um temporäre Daten zu speichern, bevor Sie sie verarbeiten. QBuffer sendet auch bytesWritten() jedes Mal, wenn neue Daten in den Puffer geschrieben wurden.

Siehe auch QFile, QDataStream, QTextStream, und QByteArray.

Dokumentation der Mitgliedsfunktionen

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

Konstruiert einen leeren Puffer mit dem angegebenen parent. Sie können setData() aufrufen, um den Puffer mit Daten zu füllen, oder Sie können ihn im Schreibmodus öffnen und write() verwenden.

Siehe auch open().

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

Konstruiert einen QBuffer, der den QByteArray, auf den byteArray zeigt, als internen Puffer verwendet, und mit dem angegebenen parent. Der Aufrufer ist dafür verantwortlich, dass byteArray gültig bleibt, bis der QBuffer zerstört wird, oder bis setBuffer() aufgerufen wird, um den Puffer zu ändern. QBuffer übernimmt nicht den Besitz des QByteArray.

Wenn Sie den Puffer im schreibgeschützten Modus oder im Schreib-Lese-Modus öffnen und etwas in den QBuffer schreiben, wird byteArray geändert.

Beispiel:

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

Siehe auch open(), setBuffer(), und setData().

[virtual noexcept] QBuffer::~QBuffer()

Zerstört den Puffer.

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

Reimplements: QIODevice::atEnd() const.

QByteArray &QBuffer::buffer()

Gibt einen Verweis auf den internen Puffer von QBuffer zurück. Sie können ihn verwenden, um QByteArray hinter dem Rücken von QBuffer zu ändern.

Siehe auch setBuffer() und data().

const QByteArray &QBuffer::buffer() const

Dies ist eine überladene Funktion.

Dies ist dasselbe wie data().

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

Reimplements: QIODevice::canReadLine() const.

[override virtual] void QBuffer::close()

Reimplements: QIODevice::close().

const QByteArray &QBuffer::data() const

Gibt die im Puffer enthaltenen Daten zurück.

Dies ist dasselbe wie buffer().

Siehe auch setData() und setBuffer().

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

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

Öffnet den Puffer mit den Flags mode und gibt bei Erfolg true zurück, andernfalls false.

Die Flags für mode müssen QIODeviceBase::ReadOnly, WriteOnly oder ReadWrite enthalten. Ist dies nicht der Fall, wird ein Fehler ausgegeben und die Methode schlägt fehl. In allen anderen Fällen ist sie erfolgreich.

Im Gegensatz zu QFile::open() wird beim Öffnen einer QBuffer mit WriteOnly die Datei nicht abgeschnitten. pos () wird jedoch auf 0 gesetzt. Verwenden Sie Append oder Truncate, um beide Verhaltensweisen zu ändern.

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

Veranlasst QBuffer, den QByteArray, auf den byteArray verweist, als internen Puffer zu verwenden. Der Aufrufer ist dafür verantwortlich, dass byteArray gültig bleibt, bis QBuffer zerstört wird oder bis setBuffer() aufgerufen wird, um den Puffer zu ändern. QBuffer übernimmt nicht das Eigentum an QByteArray.

Tut nichts, wenn isOpen() wahr ist.

Wenn Sie den Puffer im schreibgeschützten Modus oder im Schreib-Lese-Modus öffnen und etwas in den QBuffer schreiben, wird byteArray geändert.

Beispiel:

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

Wenn byteArray nullptr ist, erstellt der Puffer sein eigenes internes QByteArray, um damit zu arbeiten. Dieses Byte-Array ist anfangs leer.

Siehe auch buffer(), setData(), und open().

void QBuffer::setData(const QByteArray &data)

Setzt den Inhalt des internen Puffers auf data. Dies ist dasselbe wie die Zuweisung von data an buffer().

Tut nichts, wenn isOpen() wahr ist.

Siehe auch data() und setBuffer().

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

Dies ist eine überladene Funktion.

Setzt den Inhalt des internen Puffers auf die ersten size Bytes von data.

Hinweis: In Qt-Versionen vor 6.5 nahm diese Funktion die Länge als int -Parameter an, wodurch die Größen möglicherweise abgeschnitten wurden.

[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).

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