Fonctions de fichiers et de flux de données

La classe ` QIODevice ` est la classe d'interface de base de tous les périphériques d'E/S dans Qt Core. QIODevice fournit à la fois une implémentation commune et une interface abstraite pour les périphériques prenant en charge la lecture et l'écriture de blocs de données. Le périphérique peut être un tampon mémoire, un fichier ou un flux de données.

Certaines sous-classes, comme ` QFile `, ont été implémentées à l’aide d’un tampon mémoire pour le stockage intermédiaire des données. Cela accélère les programmes en réduisant le nombre d’opérations de lecture/écriture. La mise en tampon rend rapides des fonctions telles que ` getChar()` et ` putChar()`, car elles peuvent opérer sur le tampon mémoire plutôt que directement sur le périphérique lui-même.

La classe ` QFile ` fournit des fonctions permettant de lire et d’écrire dans des fichiers. Un ` QFile ` peut être utilisé tel quel ou, de manière plus pratique, avec un ` QTextStream ` ou un ` QDataStream`.

QBuffer permet d’accéder à un fichier « QByteArray » via l’interface « QIODevice ». Le fichier « 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'

Appelez open() pour ouvrir le tampon. Appelez ensuite write() ou putChar() pour écrire dans le tampon, et read(), readLine(), readAll() ou getChar() pour y lire. size() renvoie la taille actuelle du tampon, et vous pouvez vous positionner à n’importe quel endroit du tampon en appelant seek(). Lorsque vous avez terminé d’accéder au tampon, appelez close().

La classe ` QDataStream ` permet la sérialisation de données binaires vers un flux de données ( QIODevice). Un flux de données est un flux binaire d’informations codées qui est 100 % indépendant du système d’exploitation, du processeur ou de l’ordre des octets de l’ordinateur hôte. Par exemple, un flux de données écrit par un PC sous Windows peut être lu par un Sun SPARC fonctionnant sous Solaris. Vous pouvez également utiliser un flux de données pour lire ou écrire des données binaires brutes non codées.

Pour plus de détails sur les types de données que ` QDataStream ` peut sérialiser, consultez la section « Sérialisation des types de données Qt ».

La classe ` QTextStream ` fournit une interface pratique pour la lecture et l’écriture de texte. ` QTextStream ` peut opérer sur un fichier de type ` QIODevice`, ` QByteArray ` ou ` QString`. À l’aide des opérateurs de flux de ` QTextStream`, vous pouvez facilement lire et écrire des mots, des lignes et des nombres. Il est également courant d’utiliser ` QTextStream ` pour lire les entrées de la console et écrire les sorties de la console.

Il existe trois méthodes générales pour utiliser QTextStream lors de la lecture de fichiers texte :

• Par blocs, en appelant ` readLine()` ou ` readAll()`.
• Mot par mot. La fonction ` QTextStream ` prend en charge le flux vers des objets ` QString`, ` QByteArray` et des tampons de type `char*`. Les mots sont délimités par un espace, et les espaces en début de ligne sont automatiquement ignorés.
• Caractère par caractère, par flux vers des types ` QChar ` ou `char`. Cette méthode est souvent utilisée pour faciliter le traitement des entrées lors de l’analyse de fichiers, indépendamment du codage des caractères et de la sémantique de fin de ligne. Pour ignorer les espaces, appelez ` skipWhiteSpace()`.

QByteArray peut être utilisé pour stocker à la fois des octets bruts (y compris les \0) et des chaînes traditionnelles de 8 bits terminées par «\0 ». L’utilisation de ` QByteArray ` est bien plus pratique que celle de `const char *`. Elle garantit toujours que les données sont suivies d’un terminateur «\0 » et utilise des classes partagées implicitement (copie à l’écriture) pour réduire l’utilisation de la mémoire et éviter toute copie inutile des données.

Outre ` QByteArray`, Qt fournit également la classe ` QString ` pour stocker des données de chaîne. Dans la plupart des cas, ` QString ` est la classe la plus appropriée. Elle stocke des caractères Unicode sur 16 bits. Il est toutefois recommandé d’utiliser ` QByteArray ` lorsque vous devez stocker des données binaires brutes et lorsque l’économie de mémoire est cruciale (par exemple, avec Qt pour Linux embarqué).