Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

QBuffer Class

La classe QBuffer fournit une interface QIODevice pour un QByteArray. Plus....

En-tête : #include <QBuffer>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Héritages : QIODevice

Remarque : toutes les fonctions de cette classe sont réentrantes.

Fonctions publiques

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)

Fonctions publiques réimplémentées

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

Fonctions protégées réimplémentées

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

Description détaillée

QBuffer vous permet d'accéder à un QByteArray en utilisant l'interface QIODevice. Le QByteArray est traité comme un fichier standard à accès aléatoire. Exemple :

    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'

Par défaut, un tampon interne QByteArray est créé pour vous lorsque vous créez un QBuffer. Vous pouvez accéder directement à ce tampon en appelant buffer(). Vous pouvez également utiliser le QBuffer avec un QByteArray existant en appelant setBuffer(), ou en passant votre tableau au constructeur du QBuffer.

Appelez open() pour ouvrir le tampon. Appelez ensuite write() ou putChar() pour écrire dans le tampon, et read(), readLine(), readAll() ou getChar() pour lire dans le tampon. size() renvoie la taille actuelle de la mémoire tampon, et vous pouvez rechercher des positions arbitraires dans la mémoire tampon en appelant seek(). Lorsque vous avez fini d'accéder à la mémoire tampon, appelez close().

L'extrait de code suivant montre comment écrire des données sur un site QByteArray en utilisant QDataStream et QBuffer :

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

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

En fait, nous convertissons le site QPalette de l'application en un tableau d'octets. Voici comment lire les données à partir de QByteArray:

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

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

QTextStream et QDataStream fournissent également des constructeurs de commodité qui prennent un QByteArray et qui créent un QBuffer dans les coulisses.

QBuffer émet readyRead() lorsque de nouvelles données sont arrivées dans le tampon. En vous connectant à ce signal, vous pouvez utiliser QBuffer pour stocker des données temporaires avant de les traiter. QBuffer émet également bytesWritten() chaque fois que de nouvelles données ont été écrites dans le tampon.

Voir également QFile, QDataStream, QTextStream, et QByteArray.

Documentation des fonctions membres

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

Construit un tampon vide avec l'adresse parent. Vous pouvez appeler setData() pour remplir le tampon avec des données, ou vous pouvez l'ouvrir en mode écriture et utiliser write().

Voir aussi open().

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

Construit un QBuffer qui utilise le QByteArray pointé par byteArray comme tampon interne, et avec le parent donné. L'appelant doit s'assurer que byteArray reste valide jusqu'à ce que le QBuffer soit détruit, ou jusqu'à ce que setBuffer() soit appelé pour changer le tampon. QBuffer n'est pas propriétaire de QByteArray.

Si vous ouvrez le tampon en mode écriture seule ou en mode lecture-écriture et que vous écrivez quelque chose dans le QBuffer, byteArray sera modifié.

Exemple :

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

Voir également open(), setBuffer() et setData().

[virtual noexcept] QBuffer::~QBuffer()

Détruit le tampon.

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

Réimplémente : QIODevice::atEnd() const.

QByteArray &QBuffer::buffer()

Renvoie une référence au tampon interne de QBuffer. Vous pouvez l'utiliser pour modifier QByteArray dans le dos de QBuffer.

Voir aussi setBuffer() et data().

const QByteArray &QBuffer::buffer() const

C'est la même chose que data().

Il s'agit d'une fonction surchargée.

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

Réimplémente : QIODevice::canReadLine() const.

[override virtual] void QBuffer::close()

Réimplémente : QIODevice::close().

const QByteArray &QBuffer::data() const

Renvoie les données contenues dans le tampon.

C'est la même chose que buffer().

Voir aussi setData() et setBuffer().

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

Réimplémente : QIODevice::open(QIODeviceBase::OpenMode mode).

Ouvre le tampon en utilisant les drapeaux mode et renvoie true en cas de succès ; sinon, renvoie false.

Les drapeaux pour mode doivent inclure QIODeviceBase::ReadOnly, WriteOnly, ou ReadWrite. Si ce n'est pas le cas, une erreur est imprimée et la méthode échoue. Dans tous les autres cas, elle réussit.

Contrairement à QFile::open(), ouvrir un QBuffer avec WriteOnly ne le tronque pas. Cependant, pos() est défini sur 0. Utilisez Append ou Truncate pour modifier l'un ou l'autre comportement.

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

Réimplémente : QIODevice::pos() const.

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

Réimplémente : QIODevice::readData(char *data, qint64 maxSize).

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

Réimplémente : QIODevice::seek(qint64 pos).

void QBuffer::setBuffer(QByteArray *byteArray)

Fait en sorte que QBuffer utilise le QByteArray pointé par byteArray comme tampon interne. L'appelant doit s'assurer que byteArray reste valide jusqu'à ce que QBuffer soit détruit ou que setBuffer() soit appelé pour changer le tampon. QBuffer ne prend pas possession de QByteArray.

Ne fait rien si isOpen() est vrai.

Si vous ouvrez le tampon en mode écriture seule ou en mode lecture-écriture et que vous écrivez quelque chose dans QBuffer, byteArray sera modifié.

Exemple :

    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 est nullptr, le tampon crée son propre QByteArray interne pour travailler dessus. Ce tableau d'octets est initialement vide.

Voir également buffer(), setData() et open().

void QBuffer::setData(const QByteArray &data)

Définit le contenu du tampon interne comme étant data. C'est la même chose que d'assigner data à buffer().

Ne fait rien si isOpen() est vrai.

Voir aussi data() et setBuffer().

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

Définit le contenu du tampon interne comme étant les premiers size octets de data.

Remarque : dans les versions de Qt antérieures à la version 6.5, cette fonction prenait la longueur comme paramètre int, ce qui pouvait entraîner une troncature des tailles.

Il s'agit d'une fonction surchargée.

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

Réimplémente : QIODevice::size() const.

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

Réimplémente : 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.