Lecture/écriture de chaînes dynamiques dans un flux

Soyez le premier à donner votre avis sur cette source.

Vue 4 343 fois - Téléchargée 233 fois

Description

Pour lire ou écrire une chaine dans un flux ne vous fiez pas à ma source. Allez lire les commentaires ils sont plus pertinents, merci.

Source / Exemple :


{*******************************************************************************
 Auteur      : j1mb0
 Date        : juin 2003
 Contact     : 

 Description : - Permettre l'écriture et la lecture de chaîne dynamique
                 à l'intérieur d'un flux (ex.: un fichier).
               - Implémente une classe dérivant de TFileStream incluant
                 les fonctions.

 Commentaire : Sert pas à grand chose je l'avoue HaHaHa ;-)

                                                                                                                                                              • }
unit FileUtils; interface uses classes; function ReadData(const F : TStream; var Data; Len : Integer) : Boolean; function WriteData(const F : TStream; const Data; Len : Integer) : Boolean; function ReadString(const F : TStream; var Str : String; Len : Integer) : Boolean; function ReadString2(const F : TStream; var Str : String) : Boolean; function WriteString(const F : TStream; const Str : String) : Boolean; function WriteString2(const F : TStream; const Str : String) : Boolean; type TFileXStream = class(TFileStream) public function ReadData(var Data; Len : Integer) : Boolean; function WriteData(const Data; Len : Integer) : Boolean; function ReadString(var Str : String; Len : Integer) : Boolean; function ReadString2(var Str : String) : Boolean; function WriteString(const Str : String) : Boolean; function WriteString2(const Str : String) : Boolean; end; implementation {******************************************************************************* Classe : TFileXStream Description : Dérive de TFileStream et implémente des fonctions de lecture/écriture de chaîne dynamique dans des fichiers. Commentaire :
                                                                                                                                                              • }
function TFileXStream.ReadData(var Data; Len : Integer) : Boolean; {******************************************************************************* Description : Lire des données à l'intérieur d'un fichier. Commentaire : Paramètres : - Data / Export / Données lues - Len / Import / Nombre d'octets à lire Valeur de retour : La lecture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := FileUtils.ReadData(self, Data, Len); end; function TFileXStream.WriteData(const Data; Len : Integer) : Boolean; {******************************************************************************* Description : Écrire des données à l'intérieur d'un fichier. Commentaire : Paramètres : - Data / Import / Données à écrire - Len / Import / Nombre d'octets à lire Valeur de retour : L'écriture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := FileUtils.WriteData(self, Data, Len); end; function TFileXStream.ReadString(var Str : String; Len : Integer) : Boolean; {******************************************************************************* Description : Lire une chaîne de caractère à l'intérieur d'un fichier. Commentaire : La longueur de la chaîne est spécifiée en paramètre et non dans le fichier. Paramètres : - Str / Export / Chaîne lue - Len / Import / Longueur de la chaîne à lire Valeur de retour : La lecture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := FileUtils.ReadString(self, Str, Len); end; function TFileXStream.ReadString2(var Str : String) : Boolean; {******************************************************************************* Description : Lire une chaîne de caractère à l'intérieur d'un fichier. Commentaire : La longueur de la chaîne doit précédée la chaîne à l'intérieur du fichier. Paramètres : - Str / Export / Chaîne lue Valeur de retour : La lecture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := FileUtils.ReadString2(self, Str); end; function TFileXStream.WriteString(const Str : String) : Boolean; {******************************************************************************* Description : Écrire une chaîne de caractère à l'intérieur d'un fichier. Commentaire : La longueur de la chaîne n'est PAS écrite dans le fichier. Paramètres : - Str / Import / Chaîne à écrire Valeur de retour : L'écriture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := FileUtils.WriteString(self, Str); end; function TFileXStream.WriteString2(const Str : String) : Boolean; {******************************************************************************* Description : Écrire une chaîne de caractère à l'intérieur d'un fichier. Commentaire : La longueur de la chaîne EST écrite dans le fichier. Paramètres : - Str / Import / Chaîne à écrire Valeur de retour : L'écriture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := FileUtils.WriteString2(self, Str); end; {******************************************************************************* Description : Fonctions diverses... Commentaire :
                                                                                                                                                              • }
function ReadData(const F : TStream; var Data; Len : Integer) : Boolean; {******************************************************************************* Description : Lire des données dans un flux. Commentaire : Paramètres : - F / Import / Flux de données - Data / Export / Données lues - Len / Import / Nombre d'octets à lire Valeur de retour : La lecture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := F.Read(Data, Len) = Len; end; function WriteData(const F : TStream; const Data; Len : Integer) : Boolean; {******************************************************************************* Description : Écrire des données dans un flux. Commentaire : Paramètres : - F / Import / Flux de données - Data / Import / Données à écrire - Len / Import / Nombre d'octets à écrire Valeur de retour : L'écriture s'est bien déroulée ou non.
                                                                                                                                                              • }
begin Result := F.Write(Data, Len) = Len; end; function ReadString(const F : TStream; var Str : String; Len : Integer) : Boolean; {******************************************************************************* Description : Lire une chaîne de caractère dynamique dans un flux. Commentaire : La longueur de la chaîne n'est PAS spécifiée dans le flux. Paramètres : - F / Import / Flux de données - Str / Export / Chaîne lue - Len / Import / Longueur de la chaîne Valeur de retour : La lecture s'est bien déroulée ou non.
                                                                                                                                                              • }
var Tmp : array[1..255] of char; {Tampon.} begin {Initialiser le tampon pour qu'il soit tout propre.} FillChar(Tmp, sizeof(Tmp), 0); {Lire les données dans le flux et vérifier si le nombre d'octets lues est celui attendu.} Result := F.Read(Tmp, Len) = Len; {Vérifier si la lecture a réussie.} if Result then begin {Exporter la chaîne obtenue.} Str := Tmp; {Fixer la longueur de la chaîne.} SetLength(Str, Len); end; end; function ReadString2(const F : TStream; var Str : String) : Boolean; {******************************************************************************* Description : Lire une chaîne de caractère dynamique dans un flux. Commentaire : La longueur de la chaîne DOIT être spécifiée dans le flux. Paramètres : - F / Import / Flux de données - Str / Export / Chaîne lue Valeur de retour : La lecture s'est bien déroulée ou non.
                                                                                                                                                              • }
var Tmp : array[1..255] of char; {Tampon.} Len : Byte; {Longueur de la chaîne.} begin {Initialiser le tampon pour qu'il soit tout propre.} FillChar(Tmp, sizeof(Tmp), 0); {Lire la taille de la chaîne dans le flux et vérifier si le nombre d'octets lues est celui attendu.} Result := F.Read(Len, sizeof(Byte)) = sizeof(Byte); {Vérifier si la lecture a réussie.} if Result then begin {Lire la chaîne dans le flux...} Result := F.Read(Tmp, Len) = Len; {Vérifier si la lecture a réussie.} if Result then begin {Exporter la chaîne obtenues et fixer sa longueur avec celle lue dans le flux.} Str := Tmp; SetLength(Str, Len); end; end; end; function WriteString(const F : TStream; const Str : String) : Boolean; {******************************************************************************* Description : Écrire une chaîne de caractère dynamique dans un flux. Commentaire : La longueur de la chaîne n'est PAS écrite dans le flux. Paramètres : - F / Import / Flux de données - Str / Import / Chaîne à écrire Valeur de retour : L'écriture s'est bien déroulée ou non.
                                                                                                                                                              • }
var Tmp : array[1..255] of char; {Tampon.} i : Integer; {Indice parcourant les caractère de la chaîne.} begin {Transférer les caractères de la chaîne à l'intérieur du tampon.} for i := 1 to Length(Str) do Tmp[i] := Str[i]; {Écrire le tampon dans le flux et vérifier si le nombre d'octet écrits est celui attendu.} Result := F.Write(Tmp, Length(Str)) = Length(Str); end; function WriteString2(const F : TStream; const Str : String) : Boolean; {******************************************************************************* Description : Écrire une chaîne de caractère dynamique dans un flux. Commentaire : La longueur de la chaîne EST écrite dans le flux. Paramètres : - F / Import / Flux de données - Str / Import / Chaîne à écrire Valeur de retour : L'écriture s'est bien déroulée ou non.
                                                                                                                                                              • }
var Tmp : array[0..255] of char; {Tampon.} i : Integer; {Indice parcourant les caractère de la chaîne.} begin {Mettre la longueur de la chaîne dans l'élément 0 du tampon.} Tmp[0] := Chr(Length(Str)); {Transférer les caractères de la chaîne à l'intérieur du tampon.} for i := 1 to Length(Str) do Tmp[i] := Str[i]; {Écrire le tampon dans le flux et vérifier si le nombre d'octet écrits est celui attendu.} Result := F.Write(Tmp, Length(Str)+1) = Length(Str)+1; end; end.

Conclusion :


Lire les commentaires ci-dessous. Ils sont beaucoup plus pertinents que ma source.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
13
Date d'inscription
mardi 17 décembre 2002
Statut
Membre
Dernière intervention
27 juin 2003

Malgré que vos commentaires eux sont utiles.
Messages postés
13
Date d'inscription
mardi 17 décembre 2002
Statut
Membre
Dernière intervention
27 juin 2003

Doh!

et moi qui avait tout commenté en plus :-( lol

bonbon là je me suis gourré sur toute la ligne hahaha.

Selon vous serait-ce mieux que j'enlève cette source qui est carrément inutile ?
Messages postés
374
Date d'inscription
vendredi 20 octobre 2000
Statut
Modérateur
Dernière intervention
15 janvier 2021

Arf, vi, lol

lecture :

const MaxStringSize:=8000; // 8000 chars max ds la chaine

var p:Pchar;
begin
Getmem(p,MaxStringSize);
Stream.Readbuffer(p,MaxStringSize);
StrPas(P,Result);
Freemem(p);
end;

Ecriture:
result:=True;
if length(s)<MaxStringSize then
begin
s:=s+#0;
stream.WriteBuffer(s[1], length(s));
end
else
Result:=False;

Voila c'est beaucoups plus efficace et on doit pas stocker les longeurs de chaines...

ps:
pour le setlength :
SetLength(s, SizeOf(s)+1); // a oublier, lol



Bon coding ....

ManChesTer.
Messages postés
374
Date d'inscription
vendredi 20 octobre 2000
Statut
Modérateur
Dernière intervention
15 janvier 2021

Je pense que Laurent1313 a raison.

pour le setlength :
SetLength(s, SizeOf(s)+1);

Je ne vois pas l'interret de TFileXStream..., il n'amèliore rien, n'apoorte rien à TFileStream et rend le code plus lourd inutilement ce qui a pour effet principal de ralentir les operations de FileStream ...

Par contre le meme compos qui utiliserais les apis ou les routines de bas niveau d'écriture dans les fichiers semblerais beaucoups plus "fun" et utilisable.

Bon coding...

ManChesTer.
Messages postés
24
Date d'inscription
jeudi 19 juin 2003
Statut
Membre
Dernière intervention
15 décembre 2008

Tu te compliques la vie !! ^^ Pour écrire une chaîne dans un flux tu peux faire :
stream.WriteBuffer(s[1], length(s));
et pour la lire :
SetLength(s, tailleDeLaChaine);
stream.ReadBuffer(s[1], length(s));
Je pense que c'est bcp plus simple ! Sinon j'ai l'impression que tu limites la taille des chaînes à 256 caractères or c'est fréquent les chaînes qui dépassent cette taille.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_j1mb0)