Algorithmes et programmation en Pascal

Date de publication : 17 Novembre 2010 , Date de mise à jour : 17 Novembre 2010

VI. Fichiers séquentiels

VI.1. Le clavier et l'écran

VI.1.1. Affichage avec write

Trois ecritures equivalentes :

writeln (a, b, c, d);
write (a, b, c, d); writeln;
write(a); write(b); write(c); write(d); writeln;

• Le résultat de l'affichage dépend du type du paramètre :

VAR  e  :  integer;
     c  :  char;  
     b  :  boolean;
     r  :  real; 
     s  :  string[32]; 
 BEGIN 
  e  :=  12;  
  c  :=  'A';  
  b  :=  true;  
  r  :=  23.0;  
  s  :=  'toto'; 	
  writeln  (e,  '|',  c,  '|',  b,  '|',  r,  '|',  s);  
END.

• Soit v un entier, un booléen, un caractère ou un string. write(v:8) dit à write d'afficher v sur au moins 8 caractères. Si le nombre de caractères (signe éventuel compris) est > 8, v est complètement affiché ; si il est < 8, des espaces sont rajoutés à gauche pour compléter. .

writeln  (e:5,  '|',  c:3,  '|',  b:5,  '|',  s:6);

• Soit r un réel.
  write(r:10); dit à write d'afficher r en notation scientifique, sur au moins 10 caractères, signes de la mantisse et de l'exposant compris.
  Cette fois c'est d'abord le nombre de chiffres après la virgule qui change de 1 à 10, puis au besoin des espaces sont ajoutés à gauche.
  De plus le dernier chiffre de la mantisse affichée est arrondi.

r  :=  2  /  3; 	
writeln  (r:8,  '|',  r:10,  '|',  r:18  ); 
            

• write(r:8:4); dit à write d'afficher r en notation simple, sur au moins 8 caractères, dont 4 chiffres après la virgule (le dernier étant arrondi).
  Ainsi writeln (r:8:4);
  affiche : __0.6667

• Le formattage permet d'aligner des chiffres.
• Ne pas oublier de mettre des espaces autour des variables pour que le résultat ne soit pas tout aglutiné et illisible.
• On ne peut afficher que des types simples.

VI.1.2. Lecture avec read

Trois écritures équivalentes :

readln  (a,  b,  c,  d); 
read  (a,  b,  c,  d);  readln; 
read(a); read(b); read(c); read(d); readln; 
                           

• À l'exécution d'une de ces lignes, on peut rentrer les données en les séparant par des espaces, des tabulations ou des retours chariot
• Il faut que les données lues correspondent au type attendu de chaque variable, sinon il y a une erreur à l'exécution.

• L'utilisateur tape une série de caractères, avec de temps à autres des retours chariot
• Pendant la frappe, les caractères sont stockés dans un buffer (une mémoire tampon) ; à chaque , le contenu du buffer est envoyé au programme Pascal (y compris le ).
• De son côté, read(v); lit une donnée dans le buffer, ou attend le buffer suivant. Le read(v); attend donc quand
  - on n'a pas tapé de ,
  - ou qu'on a tapé une ligne vide,
  - ou que toutes les données dans le buffer ont déjà été lues.
• readln; attend le prochain , puis vide le buffer. Attention les données non lues dans le buffer sont alors perdues pour de futurs read().

VAR  a,  b,  c,  d  :  integer; 
BEGIN 
readln  (a,  b);	{  =  read(a); read(b); readln;  }
readln  (c,  d);
writeln  ('Lu  :  ',  a,  '  ',  b,  '  ',  c,  '  ',  d); 
END.
                          

Essais :

1 2 3 4 Lu : 1 2 3 4

1 2 3 4 Lu : 1 2 3 4

1 2 3 4 5 6 3 et 6 perdus

Produit :

1 2 3 4 Lu : 1 2 3 4 Idem

1 2 3 4 Lu : 1 2 3 4 Idem

1 2 3 4 5 6 5 et 6 perdus

VAR a, b, c, d : integer; 1 2 3 4 Lu : 1 2 3 4

VAR a, b, c, d : char; 1 2 3 4 Lu : 1 _ 2 _

CONST CarFin = '.';
VAR c : char;
BEGIN
read(c); { premier caractère }
while c <> CarFin do
begin
writeln (c, ' ', ord(c)); { option }
read(c); { caractère suivant }
end; { lu à la fin du while }
readln; { vide buffer et retour chariot }
END.

Exécution :

Salut S 83 a 97 l 108 u 117 t 116 13 10

Ciao.bye C 67 i 105 a 97 o 111

VI.2. Fichiers de disque

VI.2.1. Notions générales

1. Déclarer la variable f
   f : text ; ou f : file of qqchose ;
2. Assigner la variable f au fichier de nom nomf
   assign (f, nomf) ;
3. Ouvrir le fichier f pour pouvoir y lire ou y écrire les données
   reset (f) ; ou rewrite (f) ;
4. Lire ou écrire des données
   read (f, donnee) ; ou write (f, donnee) ;
5. Quand on a fini, on ferme le fichier
   close (f) ;

• En lecture : on fait reset(f); puis des read(f, ...); Si le fichier n'existe pas, il y a une erreur.
• En écriture : on fait rewrite(f); puis des write(f, ...); Si le fichier n'existe pas, un rewrite le crée. Si il existe déjà, le rewrite l'écrase, c'est-à-dire que l'ancien contenu est définitivement perdu.

VI.2.2. Fichiers de texte

VAR 
      f  :  text; 
      c  :  char; 
      s  :  string[255]; 
      x  :  integer; 
      r  :  real; 
	 

1. read (f, c); lit un caractère dans f.
2. readln (f, s); lit une ligne complète dans f (toujours readln sur un string).
3. read (f, x); lit un entier dans f. On peut de la même manière lire un réel.

1. write (f, c) ; écrit un caractère dans f.
2. write (f, s); écrit le string dans f. Pour passer à la ligne on fait writeln(f);
3. read (f, x); lit un entier dans f. On peut de la même manière lire un réel.
4. write (f, x, ' '); écrit un entier dans f. On peut de la même manière écrire un réel ou un booléen. Il vaut mieux rajouter un espace (ou un retour chariot) après chaque donnée pour que lors d'une relecture ultérieure, les données ne soit pas accolées en un bloc illisible.
5. write (f, r:8:2); écrit un réel formatté dans f.

VI.2.3. Fichiers d'élements

TYPE element_t = record
                  age : integer;
                  majeur : boolean;
                 end;
VAR f : file of element_t;
    e : element_t;
    

• Mettre un vecteur vec de nb éléments dans un fichier.

VAR
    vec : array [1..vmax] of element_t;
    nb, i : integer;
BEGIN
  assign (f, nomf);
  rewrite (f);
  for i := 1 to nb do
  write (f, vec[i]);
  close (f);
END;
	

• Opération inverse ; on ne connait pas nb au départ.

BEGIN
  assign (f, nomf);
  reset (f);
  nb := 0;
  while not eof(f) and (nb < vmax) do
  begin nb := nb+1; read(f, vec[nb]); end;
  close (f);
END;

VI.2.4. Gestion des erreurs

BEGIN
  assign (f, nomf);
  {$I-} rewrite (f); {$I+}
  ok := IoResult = 0;
  if not ok
  then writeln ('Erreur création fichier ', nomf)
  else begin
  ...
  write (f, ...);
  ...
  close (f);
end;
END;

BEGIN
  assign (f, nomf);
  {$I-} reset (f); {$I+}
  ok := IoResult = 0;
  if not ok then 
   writeln ('Erreur lecture fichier ', nomf) 
  else
   begin
    ...
   while not eof(f) do
   begin
    read (f, ...);
   ...
   end;
  ...
  close (f);
 end;
END;