FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 119, nombre de questions : 909, dernière mise à jour : 22 décembre 2016  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Commentez


SommaireLangageTypes de donnéesLa classe TStream (1)
précédent sommaire suivant
 

Pour écrire ou lire des données de longueur fixe dans un flux (TFileStream, TMemoryStream, bref toutes les classes dérivées de TStream), comme par exemple des types integer, double, boolean ou des types string de longueur fixe, ou même des types enregistrement (record) simples déclarés comme ceci :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
type TUnEnregistrement=record 
          Nom,Prenom,Pseudo:string[20]; 
          Age:integer; 
          InscritAuClubDVP:Boolean; 
       end; 
... 
var i:integer; 
     d:double; 
     b:boolean; 
     s:string[10]; 
     UnEnregistrement:TUnEnregistrement;
…la lecture et l'écriture dans un flux pourra toujours s'effectuer de façon similaire selon ce schéma :
Code other : Sélectionner tout
1
2
3
4
5
//Ecriture 
UnStream.Write(<variable>,SizeOf(<variable ou bien type de la variable>)); 
  
//Lecture 
UnStream.Read(<variable>,SizeOf(<variable ou bien type de la variable>));
Par exemple pour écrire nos données dans un flux :
Code delphi : Sélectionner tout
1
2
3
4
5
6
//Ecriture 
  UnStream.Write(i,SizeOf(integer)); 
  UnStream.Write(d,SizeOf(double)); 
  UnStream.Write(b,SizeOf(boolean)); 
  UnStream.Write(s,SizeOf(s)); 
  UnStream.Write(UnEnregistrement,SizeOf(TUnEnregistrement));
Et pour les lire :
Code delphi : Sélectionner tout
1
2
3
4
5
6
//Lecture 
  UnStream.Read(i,SizeOf(integer)); 
  UnStream.Read(d,SizeOf(double)); 
  UnStream.Read(b,SizeOf(boolean)); 
  UnStream.Read(s,SizeOf(s)); 
  UnStream.Read(UnEnregistrement,SizeOf(TUnEnregistrement));
Pour ce qui est des données de longueur variable (tableau dynamique, string), Delphi ne propose pas de méthode standard pour le faire, c'est donc à chacun d'en imaginer une ou bien de suivre l'exemple de la méthode proposée ci-dessous.

L'astuce consiste lors de l'écriture des données :
  1. de fournir dans un premier temps un entier qui représente le nombre de données (Nombre d'éléments d'un tableau, nombre de caractères, etc.).
  2. puis les données proprement dites.

Pour la lecture :
  1. lire le nombre de données.
  2. Adapter les dimension de la variable qui va recevoir les données en fonction de la valeur lue à l'étape 1)
  3. lire les données proprement dites.

Pour une chaine de caractères, nous vous proposons le code suivant :
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
{écrire une chaîne de caractères depuis le flux} 
procedure WriteStreamString(Stream : TStream; UneChaine : string); 
var LongueurChaine : integer; 
begin 
  {obtenir la longueur de la chaîne de caractères} 
  LongueurChaine := Length(UneChaine); 
  {écrire cette longueur dans le flux} 
  Stream.Write(LongueurChaine,SizeOf(integer)); 
  {écrire les caractères (tous d'un coup !)} 
  Stream.Write(UneChaine[1], LongueurChaine); 
end; 
  
{retourne une chaîne de caractères depuis le flux} 
function ReadStreamString(Stream : TStream) : string; 
var LongueurChaine : integer; 
begin 
  {obtenir la longueur de la chaîne de caractères} 
  Stream.Read(LongueurChaine,SizeOf(integer)); 
  {Redimensionner la chaine pour allouer la mémoire nécessaire} 
  SetLength(Result, LongueurChaine); 
  {Lire les caractères (Tous d'un coup)} 
  Stream.Read(Result[1], LongueurChaine); 
end; 
  
... 
//Utilisation de nos fonctions et procédures 
var s:string; 
    AStream:TMemoryStream; 
begin 
   AStream:=TMemoryStream.Create; 
   ... 
  
   s:='www.developpez.com, c''est génial !'; 
   //Ecriture 
   WriteStreamString(AStream,s); 
  
   ... 
  
   //Lecture 
   s:=ReadStreamString(AStream); 
   ... 
  
   AStream.Free; 
end;
Il existe aussi la méthode qui utilise les chaînes AZT (A Zéro Terminal).
Pour l'utiliser, il faut ajouter le caractère #0 à la fin de la chaine de caractères au moment de l'écriture.
Lors de la lecture, il suffit alors de parcourir le stream jusqu'à ce que l'on tombe sur #0.

Fonction de lecture :
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
function LitStringDansStream(Stream:TStream):string; 
var c:char; 
begin 
  result:=''; 
  repeat 
    stream.Read(c,1); 
    if c <> #0 then result:=result+c; 
   until c=#0; 
end;
Procédure d'écriture
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure EcritStringDansStream(Stream: TStream;Chaine:string); 
var  
  i:integer; 
  c:char; 
begin 
  if length(Chaine)>0 then 
    for i:=1 to length(Chaine) do 
    begin 
      c:=Chaine[i]; 
      stream.Write(c,1); 
    end; 
  c:=#0; 
  stream.Write(c,1); 
end;

Mis à jour le 19 janvier 2014 LadyWasky Pedro

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Delphi : Gilles Vasseur - Alcatîz -