Utilisation des flux pour lire ou écrire des données
Remonter à Utilisation des flux
Les classes de flux partagent toutes plusieurs méthodes pour lire et écrire des données. Ces méthodes se différencient selon qu'elles effectuent les opérations suivantes :
- Renvoi du nombre d'octets lus ou écrits.
- Nécessité de connaître le nombre d'octets.
- Déclenchement d'une exception en cas d'erreur.
Sommaire
Méthodes de flux pour la lecture et l'écriture
La méthode Read lit un nombre d'octets spécifié à partir du flux en commençant par sa Position en cours, dans un tampon. Read déplace ensuite la position en cours du nombre d'octets effectivement lus. Read a le prototype suivant :
C++ :
virtual int __fastcall Read(void *Buffer, int Count);
Delphi :
function Read(var Buffer; Count: Longint): Longint;
Read est utile quand le nombre d'octets du fichier est inconnu. Read renvoie le nombre d'octets effectivement transférés, qui peut être inférieur à Count si le flux ne contient pas Count octets de données après la position courante.
La méthode Write écrit Count octets d'un tampon vers le flux, en commençant à la Position courante. Write a le prototype suivant :
C++ :
virtual int __fastcall Write(const void *Buffer, int Count);
Delphi :
function Write(const Buffer; Count: Longint): Longint;
Après avoir écrit dans le fichier, Write avance la position en cours du nombre d'octets écrits et renvoie le nombre d'octets effectivement écrits, qui peut être inférieur à Count si la fin du tampon a été atteinte ou si le flux ne peut pas accepter d'autres octets.
Les procédures correspondantes sont ReadBuffer et WriteBuffer qui, à la différence de Read et Write, ne renvoient pas le nombre d'octets lus ou écrits. Ces procédures sont utiles dans les situations où le nombre d'octets est connu et obligatoire, par exemple pour la lecture de structures. ReadBuffer et WriteBuffer déclenchent une exception (EReadError et EWriteError), si le nombre d'octets ne correspond pas exactement. Les méthodes Read et Write, au contraire, peuvent renvoyer un nombre d'octets différent de la valeur demandée. Les prototypes de ReadBuffer et WriteBuffer sont :
C++ :
virtual int __fastcall ReadBuffer(void *Buffer, int Count);
virtual int __fastcall WriteBuffer(const void *Buffer, int Count);
Delphi :
procedure ReadBuffer(var Buffer; Count: Longint);
procedure WriteBuffer(const Buffer; Count: Longint);
Ces méthodes appellent les méthodes Read et Write pour réaliser la lecture et l'écriture effectives.
Lecture et écriture de composants
TStream définit des méthodes spécialisées, ReadComponent et WriteComponent, pour la lecture et l'écriture de composants. Vous pouvez les utiliser dans vos applications pour enregistrer des composants et leurs propriétés lorsque vous les créez ou que vous les modifiez lors de l'exécution.
ReadComponent et WriteComponent sont les méthodes utilisées par l'EDI pour lire ou écrire des composants dans des fichiers de fiches. Lors de la gestion de flux de composants à destination ou en provenance d'un fichier de fiche, les classes de flux fonctionnent avec les classes TFiler, TReader et TWriter pour lire des objets à partir du fichier de fiche ou les écrire sur disque.
Pour plus d'informations sur l'utilisation du système de flux de composants, voir les classes System.Classes.TStream, System.Classes.TFiler, System.Classes.TReader, System.Classes.TWriter et System.Classes.TComponent.
Lecture et écriture de chaînes
Si vous transmettez une chaîne à une fonction de lecture ou d'écriture, vous devez veiller à utiliser la bonne syntaxe. Les paramètres Buffer des routines de lecture et d'écriture sont des paramètres, respectivement, var et const. Ce sont des paramètres sans type, les routines utilisent donc l'adresse des variables.
Le type par défaut utilisé pour la manipulation de chaînes est UnicodeString. Cependant, la transmission d'une chaîne longue comme paramètre Buffer ne génère pas le résultat adéquat. Les chaînes longues contiennent une taille, un compteur de références et un pointeur sur les caractères de la chaîne. De ce fait, déréférencer une chaîne longue ne donne pas l'élément pointeur. Vous devez tout d'abord transtyper la chaîne en Pointer ou PChar, puis alors seulement la déréférencer. Par exemple :
Delphi :
procedure caststring;
var
fs: TFileStream;
const
s: string = 'Hello';
begin
fs := TFileStream.Create('temp.txt', fmCreate or fmOpenWrite);
fs.Write(s, Length(s));// this will give you garbage
fs.Write(PChar(s)^, Length(s));// this is the correct way
end;