Developpez.com

Plus de 2 000 forums
et jusqu'à 5 000 nouveaux messages par jour

Developpez.com - Pascal
X

Choisissez d'abord la catégorieensuite la rubrique :

 

CHAPITRE X : Manipulation de fichiers

Par Hugo ETIEVANT

  1. Déclaration
  2. Lecture, écriture
  3. Fonctions supplémentaires
 

1. Déclaration

Pour utiliser un ou des fichiers tout au long d'un programme, il faudra l'identifier par une variable dont le type est fonction de l'utilisation que l'on veut faire du fichier. Il existe trois types de fichiers :

  • Les fichiers textes (Text),
    qui sont écrits au format texte (chaînes de cractères, nombres) dans lesquels ont peut écrire et lire ligne par ligne ou à la file avec les procédures Write(Ln) et Read(Ln). Chaque fin de ligne du fichier se termine par les caractères 10 et 13 de la table ASCII qui signifient respectivement retour chariot et passage à la ligne. Ces deux derniers caractères sont transparent au programmeur. On pourra donc y écrire ou y lire indifférament des chaînes ou des nombres, cela dépend du type que l'on affecte à la variable passée en paramètre aux procédures d'entrée/sorties (voir plus bas).
    Note : S'il y a lieu de faire une convertion nombre/chaîne, le compilateur le fait tout seul, par contre si le type de la variable ne correspond pas avec la donnée lue dans le fichier et qu'aucune convertion n'est possible (exemple : WriteLn(f, x:Real); alors que le fichier ne contient que des lettres), alors cela produit une erreur.
    Syntaxe :

    Var f : Text ;

  • Les fichiers typés (File Of),
    qui sont des fichiers écrits sur disque telles que les données se présentent en mémoire. C'est-à-dire que la taille du fichier résultera directement et exactement de la taille en mémoire qu'occupe telle ou telle variable. Cela accrue la vitesse d'accès aux données du fichiers. Mais le plus grand avantage c'est que l'on obtient ainsi des fichiers parfaitement formatés, c'est-à-dire qu'on peut y lire et écrire directement des variables de type structuré qui contiennent plusieurs champs de données ( voir chap Type) sans avoir à se soucier des divers champs qu'elles contiennent. Il va sans dire que ce type de fichier est préférable à tous les autres.
    Syntaxe :

    Var f : File Of type ; Exemple :
    Var f : File Of Integer ;

  • Les fichiers tout court ! (File),
    qui sont des fichiers dont on ne connait pas le contenu. N'ayant aucune information sur la structure des données, n'ayant aucune convertion à faire, la lecture et son écriture en sont plus rapide. Mais sont utilité est bien maigre : à part faire une simple copie d'un fichier dans un autre...
    Syntaxe :

    Var f : File ;

 

2. Lecture, écriture

Avant de travailler sur un fichier, il faut le déclarer en lui affectant une variable qui servira à désigner le fichier tout au long du programme. Assign s'applique à tous les types de fichiers (Text, File Of et File).
Syntaxe :

Assign ( variable d'appel , nom du fichier ) ;

Ensuite, il faut renvoyer le pointeur au début du fichier pour pouvoir lire (Text, File Of et File) ou écrire (File Of et File) à partir du début du fichier. Attention, on ne peut pas écrire sur un Text avec Reset !
Syntaxe :

Reset ( variable d'appel ) ;

Il est possible pour le type File uniquement, de spécifier la taille de chaque bloc de donnée lu ou écrit sur le fichier, en rajoutant en argument à Reset une variable (ou un nombre directement) de type Word (entier) spécifiant cette taille en octet. Cela nécessite de connaître la taille mémoire de chaque type de variables (voir chap IV "Différents types de variables"). Par exemple cette taille vaudra 6 si on veut lire des nombres réels (Real) ou bien 256 pour des chaînes de caractères (String). Le fait que la variable taille soit de type Word implique que sa valeur doit être comprise entre 0 et 65535. Par défaut, taille=128 octets.
Syntaxe :

Reset ( variable d'appel, taille ) ;

Pour créer un fichier qui n'existe pas ou bien pour en effacer sont contenu, on emploi ReWrite qui pemret d'effectuer des lectures (File Of et File) et écritures (Text, File Of et File). Attention, on ne peut pas lire sur un Text avec ReWrite !
Syntaxe :

Rewrite ( variable d'appel ) ;

Tout comme Reset, ReWrite permet de spécifier une taille aux échanges de données sur un File seulement (aussi bien en écriture qu'en lecture). Avec ReWrite c'est le cas ou le fichier n'existe pas encore alors qu'avec Reset c'est le cas ou il existe déjà.
Syntaxe :

Rewrite ( variable d'appel, taille) ;

Tableau des correspondances entre procédures et types de fichiers
SyntaxeTypes de fichiers associés
LectureEcriture
Reset(f) - Text
- File Of
- File
- File Of
- File
ReWrite(f) - File Of
- File
- Text
- File Of
- File
Reset(f, taille) FileFile
ReWrite(f, taille) FileFile

Pour lire le contenu d'une ligne d'un fichier Text ouvert, on utilise la même instruction qui permet de lire la valeur d'une variable au clavier à savoir ReadLn. Sera alors lue, la ou les variable(s) correspondant au contenu de la ligne courante (celle pointée par le pointeur). Si la ou les variable(s) n'étai(en)t pas de taille suffisament grande pour contenir toutes les données de la ligne, alors l'exédent serait perdu.
Syntaxes :

ReadLn ( variable d'appel, variable ) ;
ReadLn ( variable d'appel, var1, var2, ... varN) ;

Pour écrire sur un fichier Text, il suffit d'employer la commande WriteLn.
Syntaxes :

WriteLn ( variable d'appel, variable ) ;
WriteLn ( variable d'appel, var1, var2, ... varN) ;

Les procédures Read et Write s'utilisent respectivement de la même manière que ReadLn et WriteLn mais s'appliquent aux File Of aussi bien qu'aux Text.

Pour lire et écrire sur un File, il faut utiliser les procédures BlockRead et BlockWrite.
Syntaxes :

BlockRead ( f, variable, nbr ) ;
BlockRead (
f, variable, nbr, result ) ;
BlockWrite (
f, variable, nbr ) ;
BlockWrite (
f, variable, nbr, result ) ;

BlockRead lit sur le fichier f de type File une variable qui contiendra un nombre de bloc mémoire (dont la taille est définie par Reset ou ReWrite) égale à nbr. La variable facultative result prend pour valeur le nombre de bloc effectivement lu (car il peut y en avoir moins que prévu initialement).

BlockWrite écrit sur le fichier f de type File une variable sur un nombre de bloc mémoire égale à nbr. La variable facultative result prend pour valeur le nombre de bloc effectivement écrit (car il peut y en avoir plus à écrire que ne le permet l'initialisation par Reset ou ReWrite). Dans le cas ou cette variable result est ommise et qu'il est impossible d'écrire autant de blocs que voulu, il est généré une erreur !

Note : Les variables nbr et result doivent être de type Word.

Tableau des correspondances entre procédures et types de fichiers
SyntaxeTypes de fichiers associés
WriteLnText
ReadLnText
Write- Text
- File Of
Read- Text
- File Of
BlockWriteFile
BlockReadFile

Il est impératif de fermer les fichiers ouverts pendant un programme Turbo Pascal avant de terminer le programme sous peine de voir les données inscrites en son sein perdues.
Syntaxe :

Close ( variable d'appel ) ;

Il est possible de rappeler un fichier Text en cours de programme même s'il a déjà été refermé grâce à sa variable d'appel. Et alors la position courante du curseur sera à la fin du fichier. Ne fonctionne qu'en écriture et qu'avec un Text.
Syntaxe :

Append ( variable d'appel ) ;

La syntaxe Append est équivalente au bloc suivant :

Begin
Reset(
variable d'appel) ;
Seek(
variable d'appel, FileSize(variable d'appel)) ;
End ;


Program exemple12 ;
Uses crt, dos ;
Var f : text ;
    nom : string ;
    choix : char ;
Procedure
lecture ;
Begin
Append (f) ;
Reset (f) ;
Readln (f, nom) ;
Writeln (nom) ;
End ;
BEGIN
Clrscr ;
Assign (f, '
init.txt') ;
Rewrite (f) ;
Write ('
Entrez un nom d''utilisateur : ') ;
Readln (nom) ;
nom := '
Dernier utilisateur : ' + nom ;
Writeln (f, nom) ;
Close (f) ;
Write ('
Voulez-vous lire le fichier init.txt ? [O/N] ') ;
Readln (choix) ;
If (choix='O') or (choix='o') then
lecture ;
END.

Ce programme exemple12 illustre les principales commandes qui permettent de travailler sur des fichiers de type texte. Ici, le programme réinitialise à chaque lancement le fichier init.txt et y inscrit une valeur entrée par l'utilisateur (son nom, en l'occurrence). Il permet également à l'utilisateur de lire le contenu du fichier (qui ne contient qu'une seule ligne de texte).


 

3. Fonctions supplémentaires

Il est possible de déplacer à volonté le curseur en spécifiant à la procédure suivante le fichier de type File Of ou File ainsi que le numéro de l'octet (le premier à pour numéro :"0", le second : "1", le troisième : "2", etc...) où l'on veut mettre le curseur. Cela s'appelle l'accès direct à un fichier contrairement à l'accès séquentiel qui conciste à parcourir toutes les informations précédant celle qu'on cherche. Cette dernière méthode séquentielle est toutefois la plus utilisée. De plus, Seek n'est pas utilisable avec des Text.
Syntaxe :

Seek ( variable d'appel, position ) ;

Program exemple13 ;
Uses crt, dos ;
Var f : text ;
    s : string ;
BEGIN
Assign (f, 'c:\autoexec.bat') ;
Reset (f) ;
Writeln ('
Affichage du contenu du fichier AUTOEXEC.BAT : ') ;
Repeat
Readln (f, s) ;
Writeln (s) ;
Until eof (f) ;
END.

Ce programme exemple13 permet de lire un fichier texte en son entier et d'afficher son contenu à l'écran. La fonction eof permet de vérifier si le pointeur arrive en fin de fichier (elle aura alors la valeur true).

Il est possible de connaître la taille d'un fichier en octets lorsque celui-ci est déclaré en file et non plus en text.
Syntaxe :

FileSize ( variable d'appel ) ;

Il est possible de connaître la position du pointeur dans fichier en octets lorsque celui-ci est déclaré en file of byte. La fonction suivante prend pour valeur un type longint.
Syntaxe :

FilePos ( variable d'appel ) ;

Program
exemple14 ;
Var f : file of byte ;
    taille : longint;
BEGIN
Assign (f, 'c:\autoexec.bat') ;
Reset (f) ;
taille := filesize (f) ;
Writeln ('
Taille du fichier en octets :', taille ) ;
Writeln ('
Déplacement du curseur...') ;
Seek (f, taille div 2);
Writeln ('
Le pointeur se trouve à l''octet : ', filepos (f) ) ;
Close (f) ;
END.

Le programme exemple14 déclare le fichier autoexec.bat comme file of byte et nom plus comme text, puisqu'on ne désire plus écrire du texte dedans mais seulement connaître sa taille et accessoirement faire mumuse avec le pointeur.

Il est possible de savoir si lors de la lecture d'un fichier, on se trouve ou non en find de ligne ou de fichier grâce aux fonctions suivantes qui renvoient une valeur de type boolean.
Syntaxe :

Var f : Text ;
Eof ( f ) ; {
Pointeur en fin de fichier. }
SeekEoLn ( f ) ; {
Pointeur en fin de ligne. }

Autre syntaxe :

Var f : File ;
EoLn ( f ) ; {
Pointeur en fin de ligne. }
SeekEof ( f ) ; {
Pointeur en fin de fichier. }

Program exemple15 ;
Var f : text ;
    i, j : string ;
BEGIN
Assign (f, 'c:\autoexec.bat') ;
Reset (f) ;
While not seekeof (f) do
Begin
If seekeoln (f) then readln ;
Read (f, j) ;
Writeln (j) ;
End ;
END.

On peut également effacer un fichier préalablement fermé.
Syntaxe:

Erase (f) ;

On peut aussi renomer un fichier.
Syntaxe :

Rename (f, nouveau nom ) ;

Il est possible de tronquer un fichier, c'est-à-dire de supprimer tout ce qui se trouve après la position courante du pointeur.
Syntaxe :

Truncate (f) ;

Il est possible d'appeler un fichier exécutable externe à partir d'un programme écrit en Pascal, et de lui assigner des paramètres grâce à la commande Exec. Cette commande nécessite un commentaire de compilation : { $M $4000,0,0 }.
Syntaxe :

SwapVectors ;
Exec (
nom+chemin, paramètres ) ;
SwapVectors ;

Pour télécharger un programme utilisant la commande Exec pour utiliser le compacteur ARJ grâce à une interface ulta-simplifiée : A.PAS.

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