QTextStream Class

Documentation sur les fonctions membres

QTextStream::QTextStream()

Crée un objet QTextStream. Avant de pouvoir l'utiliser pour lire ou écrire, vous devez lui attribuer un périphérique ou une chaîne de caractères.

Voir également setDevice() et setString().

[explicit] QTextStream::QTextStream(QIODevice *device)

Crée un objet QTextStream qui fonctionne sur device.

[explicit] QTextStream::QTextStream(FILE *fileHandle, QIODeviceBase::OpenMode openMode = ReadWrite)

Crée un objet `QTextStream` qui opère sur ` fileHandle`, en utilisant ` openMode ` pour définir le mode d'ouverture. En interne, un objet ` QFile ` est créé pour gérer le pointeur `FILE`.

Ce constructeur est utile pour travailler directement avec les flux d'entrée et de sortie courants basés sur FILE : stdin, stdout et stderr. Exemple :

QString str;
QTextStream in(stdin);
in >> str;

[explicit] QTextStream::QTextStream(QByteArray *array, QIODeviceBase::OpenMode openMode = ReadWrite)

Crée un objet `QTextStream` qui opère sur ` array`, en utilisant ` openMode ` pour définir le mode d'ouverture. En interne, le tableau est encapsulé dans un objet ` QBuffer`.

[explicit] QTextStream::QTextStream(QString *string, QIODeviceBase::OpenMode openMode = ReadWrite)

Crée un objet `QTextStream` qui opère sur ` string`, en utilisant ` openMode ` pour définir le mode d'ouverture.

[explicit] QTextStream::QTextStream(const QByteArray &array, QIODeviceBase::OpenMode openMode = ReadOnly)

Crée un objet QTextStream qui opère sur array, en utilisant openMode pour définir le mode d'ouverture. L'accès au tableau se fait en lecture seule, quelles que soient les valeurs contenues dans openMode.

Ce constructeur est pratique pour travailler sur des chaînes constantes. Exemple :

int main(int argc, char *argv[])
{
    // read numeric arguments (123, 0x20, 4.5...)
    for (int i = 1; i < argc; ++i) {
        int number;
        QTextStream in(argv[i]);
        in >> number;
        //...
    }
}

[virtual noexcept] QTextStream::~QTextStream()

Détruit l'QTextStream.

Si le flux s'exécute sur un périphérique, la méthode flush() sera appelée implicitement. Dans le cas contraire, le périphérique n'est pas affecté.

bool QTextStream::atEnd() const

Renvoie « true » s'il n'y a plus de données à lire depuis l'QTextStream; sinon, renvoie « false ». Cette opération est similaire à l'appel de la fonction QIODevice::atEnd(), mais n'est pas identique, car QTextStream prend également en compte son tampon Unicode interne.

bool QTextStream::autoDetectUnicode() const

Renvoie « true » si la détection automatique d'Unicode est activée ; sinon, renvoie « false ». La détection automatique d'Unicode est activée par défaut.

Voir également setAutoDetectUnicode() et setEncoding().

QIODevice *QTextStream::device() const

Renvoie le périphérique actuel associé à l'QTextStream, ou nullptr si aucun périphérique n'a été attribué.

Voir également setDevice() et string().

QStringConverter::Encoding QTextStream::encoding() const

Renvoie le codage actuellement attribué au flux.

Voir également setEncoding(), setAutoDetectUnicode() et locale().

QTextStream::FieldAlignment QTextStream::fieldAlignment() const

Renvoie l'alignement actuel du champ.

Voir également setFieldAlignment() et fieldWidth().

int QTextStream::fieldWidth() const

Renvoie la largeur actuelle du champ.

Voir aussi setFieldWidth().

void QTextStream::flush()

Vide toutes les données mises en mémoire tampon en attente d'écriture sur le périphérique.

Si la fonction ` QTextStream ` porte sur une chaîne de caractères, cette fonction ne fait rien.

bool QTextStream::generateByteOrderMark() const

Renvoie « true » si « QTextStream » est défini pour générer le BOM (Byte Order Mark) UTF lors de l'utilisation d'un encodage UTF ; sinon, renvoie « false ». La génération du BOM UTF est désactivée par défaut.

Voir également setGenerateByteOrderMark().

int QTextStream::integerBase() const

Renvoie la base actuelle des nombres entiers. La valeur 0 signifie que la base est détectée lors de la lecture, ou 10 (décimal) lors de la génération de nombres.

Voir également setIntegerBase(), QString::number() et numberFlags().

QLocale QTextStream::locale() const

Renvoie les paramètres régionaux de ce flux. Les paramètres régionaux par défaut sont « C ».

Voir également setLocale().

QTextStream::NumberFlags QTextStream::numberFlags() const

Renvoie les indicateurs de numéro actuels.

Voir également setNumberFlags(), integerBase() et realNumberNotation().

QChar QTextStream::padChar() const

Renvoie le caractère de remplissage actuel.

Voir également setPadChar() et setFieldWidth().

qint64 QTextStream::pos() const

Renvoie la position du périphérique correspondant à la position actuelle du flux, ou -1 en cas d'erreur (par exemple, s'il n'y a pas de périphérique ou de chaîne, ou en cas d'erreur liée au périphérique).

QTextStream étant mis en mémoire tampon, cette fonction peut être amenée à rechercher le périphérique afin de reconstituer une position valide. Cette opération pouvant être coûteuse en ressources, il est préférable d’éviter d’appeler cette fonction dans une boucle serrée.

Voir également seek().

QString QTextStream::read(qint64 maxlen)

Lit au maximum maxlen caractères à partir du flux et renvoie les données lues sous la forme d'un objet ` QString`.

Voir également readAll(), readLine() et QIODevice::read().

QString QTextStream::readAll()

Lit l'intégralité du contenu du flux et le renvoie sous la forme d'un objet ` QString`. Évitez d'utiliser cette fonction lorsque vous travaillez sur des fichiers volumineux, car elle consomme une quantité importante de mémoire.

Il est préférable d'appeler ` readLine()` si vous ne connaissez pas la quantité de données disponibles.

Voir également readLine().

QString QTextStream::readLine(qint64 maxlen = 0)

Lit une ligne de texte à partir du flux et la renvoie sous la forme d’un objet ` QString`. La longueur maximale autorisée pour une ligne est définie à ` maxlen`. Si le flux contient des lignes plus longues que cette valeur, celles-ci seront fractionnées après ` maxlen ` caractères et renvoyées par parties.

Si maxlen est égal à 0, les lignes peuvent être de n’importe quelle longueur.

La ligne renvoyée ne comporte pas de caractères de fin de ligne («\n » ou «\r\n »), de sorte qu’il n’est pas nécessaire d’appeler QString::trimmed().

Si le flux a été lu jusqu'à la fin du fichier, readLine() renverra une valeur nulle pour QString. Pour les chaînes de caractères, ou pour les périphériques qui le prennent en charge, vous pouvez vérifier explicitement la fin du flux à l'aide de atEnd().

Voir également readAll() et QIODevice::readLine().

bool QTextStream::readLineInto(QString *line, qint64 maxlen = 0)

Lit une ligne de texte à partir du flux et la stocke dans ` line`. Si ` line ` est égal à ` nullptr`, la ligne lue n’est pas stockée.

La longueur maximale autorisée pour une ligne est définie sur maxlen. Si le flux contient des lignes plus longues que cela, celles-ci seront coupées après maxlen caractères et renvoyées par parties.

Si maxlen vaut 0, les lignes peuvent être de n'importe quelle longueur.

La ligne obtenue ne comporte pas de caractères de fin de ligne («\n » ou «\r\n »), de sorte que l’appel à QString::trimmed() peut s’avérer inutile.

Si ` line ` dispose d’une capacité suffisante pour les données sur le point d’être lues, cette fonction n’aura peut-être pas besoin d’allouer de nouvelle mémoire. De ce fait, elle peut s’avérer plus rapide que ` readLine()`.

Renvoie false si le flux a lu jusqu’à la fin du fichier ou si une erreur s’est produite ; sinon, renvoie true. Le contenu de line avant l’appel est dans tous les cas ignoré.

Voir également readAll(), QIODevice::readLine() et QIODevice::readLineInto().

QTextStream::RealNumberNotation QTextStream::realNumberNotation() const

Renvoie la notation actuelle des nombres réels.

Voir également setRealNumberNotation(), realNumberPrecision(), numberFlags() et integerBase().

int QTextStream::realNumberPrecision() const

Renvoie la précision actuelle des nombres réels, c'est-à-dire le nombre de chiffres décimaux que QTextStream affichera lors de la génération de nombres réels (FixedNotation, ScientificNotation), ou le nombre maximal de chiffres significatifs (SmartNotation).

Voir également setRealNumberPrecision(), setRealNumberNotation(), realNumberNotation(), numberFlags() et integerBase().

void QTextStream::reset()

Réinitialise les options de mise en forme de ` QTextStream`, le ramenant à son état initial. Le périphérique, la chaîne et toutes les données mises en mémoire tampon restent inchangés.

void QTextStream::resetStatus()

Réinitialise l'état du flux de texte.

Voir également QTextStream::Status, status() et setStatus().

bool QTextStream::seek(qint64 pos)

Recherche la position pos dans le périphérique. Renvoie true en cas de succès ; sinon, renvoie false.

void QTextStream::setAutoDetectUnicode(bool enabled)

Si la variable ` enabled ` est définie sur `true`, la fonction ` QTextStream ` tentera de détecter l'encodage Unicode en analysant les données du flux afin de vérifier si elle peut trouver la marque d'ordre des octets (BOM) UTF-8, UTF-16 ou UTF-32. Si cette marque est détectée, la fonction ` QTextStream ` remplacera l'encodage actuel par l'encodage UTF.

Cette fonction peut être utilisée conjointement avec setEncoding(). Il est courant de définir l’encodage sur UTF-8, puis d’activer la détection de l’UTF-16.

Voir également autoDetectUnicode() et setEncoding().

void QTextStream::setDevice(QIODevice *device)

Définit le périphérique actuel sur device. Si un périphérique a déjà été attribué, QTextStream appellera flush() avant de remplacer l'ancien périphérique.

Voir également device() et setString().

[since 6.0] void QTextStream::setEncoding(QStringConverter::Encoding encoding)

Définit l'encodage de ce flux sur « encoding ». Cet encodage est utilisé pour décoder toutes les données lues à partir du périphérique associé, ainsi que pour encoder toutes les données écrites. Par défaut, l'encodage « QStringConverter::Utf8 » est utilisé et la détection automatique de l'Unicode est activée.

Si ` QTextStream ` s'applique à une chaîne de caractères, cette fonction ne fait rien.

Cette fonction a été introduite dans Qt 6.0.

Voir également encoding(), setAutoDetectUnicode() et setLocale().

void QTextStream::setFieldAlignment(QTextStream::FieldAlignment mode)

Définit l'alignement du champ sur « mode ». Utilisée conjointement avec la fonction « setFieldWidth() », cette fonction vous permet de générer une sortie formatée avec du texte aligné à gauche, à droite ou au centre.

Voir également fieldAlignment() et setFieldWidth().

void QTextStream::setFieldWidth(int width)

Définit la largeur de champ actuelle sur width. Si width est égal à 0 (valeur par défaut), la largeur de champ est égale à la longueur du texte généré.

Voir également fieldWidth() et setPadChar().

void QTextStream::setGenerateByteOrderMark(bool generate)

Si generate est vrai et qu'un encodage UTF est utilisé, QTextStream insère le BOM (Byte Order Mark) avant que des données ne soient écrites sur le périphérique. Si generate est faux, aucun BOM n'est inséré. Cette fonction doit être appelée avant toute écriture de données. Sinon, elle n'a aucun effet.

Voir également generateByteOrderMark() et bom().

void QTextStream::setIntegerBase(int base)

Définit la base des nombres entiers sur base, tant pour la lecture que pour la génération de nombres. base peut prendre la valeur 2 (binaire), 8 (octal), 10 (décimal) ou 16 (hexadécimal). Si base vaut 0, QTextStream tentera de détecter la base en analysant les données du flux. Lors de la génération de nombres, QTextStream suppose que la base est 10, sauf si celle-ci a été explicitement définie.

Voir également integerBase(), QString::number() et setNumberFlags().

void QTextStream::setLocale(const QLocale &locale)

Définit les paramètres régionaux de ce flux sur locale. Les paramètres régionaux spécifiés sont utilisés pour les conversions entre les nombres et leurs représentations sous forme de chaînes de caractères.

La locale par défaut est C ; il s'agit d'un cas particulier : le séparateur de milliers n'est pas utilisé pour des raisons de compatibilité ascendante.

Voir également locale().

void QTextStream::setNumberFlags(QTextStream::NumberFlags flags)

Définit les indicateurs de nombre actuels sur flags. flags est un ensemble d'indicateurs issus de l'énumération NumberFlag, qui décrit les options de mise en forme du code généré (par exemple, s'il faut ou non toujours indiquer la base ou le signe d'un nombre).

Voir également numberFlags(), setIntegerBase() et setRealNumberNotation().

void QTextStream::setPadChar(QChar ch)

Définit le caractère de remplissage sur « ch ». La valeur par défaut est le caractère ASCII « espace » (« »), soit QChar(0x20). Ce caractère sert à remplir les espaces vides dans les champs lors de la génération de texte.

Exemple :

QString s;
QTextStream out(&s);
out.setFieldWidth(10);
out.setFieldAlignment(QTextStream::AlignCenter);
out.setPadChar('-');
out << "Qt" << "rocks!";

La chaîne s contient :

----Qt------rocks!--

Voir également padChar() et setFieldWidth().

void QTextStream::setRealNumberNotation(QTextStream::RealNumberNotation notation)

Définit la notation des nombres réels sur notation (SmartNotation, FixedNotation, ScientificNotation). Lors de la lecture et de la génération de nombres, QTextStream utilise cette valeur pour détecter le formatage des nombres réels.

Voir également realNumberNotation(), setRealNumberPrecision(), setNumberFlags() et setIntegerBase().

void QTextStream::setRealNumberPrecision(int precision)

Définit la précision des nombres réels à precision. Cette valeur indique le nombre de chiffres décimaux que QTextStream doit afficher lors de la génération de nombres réels (FixedNotation, ScientificNotation), ou le nombre maximal de chiffres significatifs (SmartNotation).

La précision ne peut pas être une valeur négative. La valeur par défaut est 6.

Voir également realNumberPrecision() et setRealNumberNotation().

void QTextStream::setStatus(QTextStream::Status status)

Définit l'état du flux de texte sur l'status e spécifiée.

Les appels suivants à `setStatus()` sont ignorés jusqu’à ce que ` resetStatus()` soit appelé.

Voir également Status, status() et resetStatus().

void QTextStream::setString(QString *string, QIODeviceBase::OpenMode openMode = ReadWrite)

Définit la chaîne actuelle sur string, en utilisant l'openMode fournie. Si un périphérique a déjà été attribué, QTextStream appellera flush() avant de le remplacer.

Voir également string() et setDevice().

void QTextStream::skipWhiteSpace()

Lit et ignore les espaces blancs du flux jusqu'à ce qu'un caractère autre qu'un espace soit détecté, ou jusqu'à ce que la fonction atEnd() renvoie la valeur « true ». Cette fonction est utile lors de la lecture d'un flux caractère par caractère.

Les caractères d'espacement sont tous les caractères pour lesquels la fonction ` QChar::isSpace()` renvoie ` true`.

Voir également la fonction ` operator>>()`.

QTextStream::Status QTextStream::status() const

Renvoie l'état du flux de texte.

Voir également QTextStream::Status, setStatus() et resetStatus().

QString *QTextStream::string() const

Renvoie la chaîne de caractères actuellement associée à l'QTextStream, ou nullptr si aucune chaîne n'a été associée.

Voir également setString() et device().

[explicit noexcept, since 6.10] QTextStream::operator bool() const

Indique si ce flux ne présente aucune erreur (la fonction `status()` renvoie ` Ok`).

Cette fonction a été introduite dans Qt 6.10.

QTextStream &QTextStream::operator<<(QChar c)

Écrit le caractère c dans le flux, puis renvoie une référence à l'QTextStream.

Voir aussi setFieldWidth().

QTextStream &QTextStream::operator<<(const QString &string)

Écrit la chaîne « string » dans le flux et renvoie une référence à l'objet ` QTextStream`. La chaîne est d'abord encodée selon l'encodage spécifié (UTF-8 par défaut) avant d'être écrite dans le flux.

Voir également setFieldWidth() et setEncoding().

QTextStream &QTextStream::operator<<(float f)

Écrit le nombre réel f dans le flux, puis renvoie une référence à QTextStream. Par défaut, QTextStream le stocke en utilisant SmartNotation, avec une précision pouvant aller jusqu’à 6 chiffres. Vous pouvez modifier la représentation textuelle que QTextStream utilisera pour les nombres réels en appelant setRealNumberNotation(), setRealNumberPrecision() et setNumberFlags().

Voir également setFieldWidth(), setRealNumberNotation(), setRealNumberPrecision() et setNumberFlags().

QTextStream &QTextStream::operator<<(short i)

Écrit le nombre entier i dans le flux, puis renvoie une référence vers QTextStream. Par défaut, le nombre est stocké sous forme décimale, mais vous pouvez également définir la base en appelant la fonction setIntegerBase().

Voir également setFieldWidth() et setNumberFlags().

QTextStream &QTextStream::operator<<(QLatin1StringView string)

Écrit string dans le flux et renvoie une référence à l'QTextStream.

QTextStream &QTextStream::operator<<(QStringView string)

Écrit string dans le flux et renvoie une référence à l’ QTextStream.

QTextStream &QTextStream::operator<<(char c)

Convertit c du format ASCII au format QChar, puis l'écrit dans le flux.

[since 6.3.1] QTextStream &QTextStream::operator<<(char16_t c)

Écrit le caractère Unicode c dans le flux, puis renvoie une référence à l'QTextStream.

Cette fonction a été introduite dans Qt 6.3.1.

QTextStream &QTextStream::operator<<(const QByteArray &array)

Écrit array dans le flux. Le contenu de array est converti à l'aide de QString::fromUtf8().

QTextStream &QTextStream::operator<<(const char *string)

Écrit dans le flux la chaîne constante pointée par ` string `. On suppose que ` string ` est encodée en UTF-8. Cet opérateur est pratique lorsqu'on travaille avec des données de type chaîne constante. Exemple :

QTextStream out(stdout);
out << "Qt rocks!" << Qt::endl;

Avertissement : QTextStream suppose que string pointe vers une chaîne de texte terminée par un caractère «\0 ». S'il n'y a pas de caractère de fin «\0 », votre application risque de planter.

QTextStream &QTextStream::operator<<(const void *ptr)

Écrit la valeur « ptr » dans le flux sous la forme d'un nombre hexadécimal avec une base.

QTextStream &QTextStream::operator<<(double f)

Écrit la double f e dans le flux.

QTextStream &QTextStream::operator<<(int i)

Écrit l'entier signé i dans le flux.

QTextStream &QTextStream::operator<<(long i)

Écrit l'i de type long signé dans le flux.

QTextStream &QTextStream::operator<<(qlonglong i)

Écrit l'i de type qlonglong dans le flux.

QTextStream &QTextStream::operator<<(qulonglong i)

Écrit l'i « qulonglong » dans le flux.

QTextStream &QTextStream::operator<<(unsigned int i)

Écrit l'i de type unsigned int dans le flux.

QTextStream &QTextStream::operator<<(unsigned long i)

Écrit la valeur « unsigned long » i dans le flux.

QTextStream &QTextStream::operator<<(unsigned short i)

Écrit l'i de type unsigned short dans le flux.

QTextStream &QTextStream::operator>>(QChar &c)

Lit un caractère dans le flux et le stocke dans ` c`. Renvoie une référence à ` QTextStream`, ce qui permet d'imbriquer plusieurs opérateurs. Exemple :

QTextStream in(file);
QChar ch1, ch2, ch3;
in >> ch1 >> ch2 >> ch3;

Les espaces ne sont pas ignorés.

QTextStream &QTextStream::operator>>(QString &str)

Lit un mot dans le flux et le stocke dans ` str`, puis renvoie une référence au flux. Les mots sont séparés par des espaces (c'est-à-dire tous les caractères pour lesquels la fonction ` QChar::isSpace()` renvoie ` true`).

Les espaces en début de mot sont ignorés.

QTextStream &QTextStream::operator>>(float &f)

Lit un nombre réel à partir du flux et le stocke dans ` f`, puis renvoie une référence à ` QTextStream`. Le nombre est converti au type approprié. Si aucun nombre réel n’est détecté dans le flux, ` f ` est défini à 0,0.

À titre d’exception, ` QTextStream ` autorise les chaînes « nan » et « inf » pour représenter respectivement les nombres flottants NAN et INF (de type float ou double).

Les espaces en début de chaîne sont ignorés.

QTextStream &QTextStream::operator>>(short &i)

Lit un entier à partir du flux et le stocke dans ` i`, puis renvoie une référence à ` QTextStream`. Le nombre est converti au type approprié avant d'être stocké. Si aucun nombre n'a été détecté dans le flux, ` i ` est défini à 0.

Par défaut, ` QTextStream ` tentera de détecter la base du nombre en utilisant les règles suivantes :

En appelant la fonction ` setIntegerBase()`, vous pouvez spécifier explicitement la base du nombre entier. Cela désactivera la détection automatique et accélérera légèrement l'QTextStream.

Les espaces en début de ligne sont ignorés.

QTextStream &QTextStream::operator>>(QByteArray &array)

Convertit le mot au format UTF-8, puis l'enregistre dans ` array`.

Voir également QString::toLatin1().

QTextStream &QTextStream::operator>>(char &c)

Lit un caractère dans le flux et le stocke dans ` c`. Le caractère provenant du flux est converti au format ISO-8859-1 avant d'être stocké.

Voir également QChar::toLatin1().

[since 6.4] QTextStream &QTextStream::operator>>(char16_t &c)

Lit un caractère dans le flux et le stocke dans ` c`.

Cette fonction a été introduite dans Qt 6.4.

QTextStream &QTextStream::operator>>(double &f)

Enregistre le nombre réel dans la variable de type double « f ».

QTextStream &QTextStream::operator>>(int &i)

Stocke l'entier dans la variable de type « signed int » i.

QTextStream &QTextStream::operator>>(long &i)

Stocke l'entier dans le type « long » signé i.

QTextStream &QTextStream::operator>>(qlonglong &i)

Enregistre l'entier dans la variable ` i` de type `qlonglong`.

QTextStream &QTextStream::operator>>(qulonglong &i)

Enregistre l'entier dans le champ « qulonglong » i.

QTextStream &QTextStream::operator>>(unsigned int &i)

Stocke l'entier dans l'i de type unsigned int.

QTextStream &QTextStream::operator>>(unsigned long &i)

Stocke l'entier dans le type « unsigned long » i.

QTextStream &QTextStream::operator>>(unsigned short &i)

Stocke l'entier dans l'i de type « unsigned short ».