Cours pascal

Par Nabster (hello world) (Blog)
 

    

           

V. Tableaux

On appelle souvent vecteur un tableau en une dimension.

V.1. Le type array

V.1.1. Principe

array [ I ] of T 

TYPE vec_t = array [1..10] of integer;
VAR v : vec_t; 

• À la déclaration, le contenu du tableau est indéterminé, comme toute variable.
• On accède à la case indice i par v[i] (et non v(i)).
• Pour mettre toutes les cases à 0 on fait

for i := 1 to 10 do
 v[i] := 0; 

TYPE interv = 1..10 ; 
vec_t = array [ interv ] of	integer; 

V.1.2. Contrôle des bornes

CONST vec_min = 1;
      vec_max = 10;
TYPE vec_t = array[vec_min..vec_max] of integer; 

CONST vec_min = 1;
      vec_max = 10;
TYPE vec_t = array[vec_min..vec_max] of integer;
VAR v : vect_t;
    i : integer;
BEGIN
  write ('i ? ');
  readln(i);
  if (i  >=  vec_min) and  (i  <=  vec_max) then
  begin
	write  ('v[',  i,  ']  ?  ');
	readln(v[i]);
  end
  else
	writeln('Erreur, i  hors  intervalle  ', vec_min,  '..',  vec_max);
END.

if  (i  >=  vec_min) and  (i  <=  vec_max) and  (v[i]  <>  -1)  then
   ... 
else
   ...; 
						   

if  (i  >=  vec_min) and  (i  <=  vec_max) then
   if  (v[i]  <>  -1)  then 
     ...
   else
     ...
else
    ...  {  erreur hors  bornes  }  ; 

V.1.3. Recopie

for  i  :=  vec_min  to  vec_max  do
  v2[i]  :=  v1[i]; 

TYPE vecA  =  array  [1..10]  of  char;
     vecB  =  array  [1..10]  of  char;
VAR v1  :  vecA;
	v2  :  vecA;
	v3  :  vecB;
BEGIN 
  v2  :=  v1;	{  legal  car  meme  type  vecA  }
  v3  :=  v1;	{  illegal, objets  de  types  <>  vecA  et  vecB  }
						      		

V.2. Super tableaux

V.2.1. Tableaux à plusieurs dimensions

• v1 : array [1..10] of array [1..20] of real -> Tableau de 10 éléments, chaque élément étant un tableau de 20 réels. On accède à l'élément d'indice i dans 1..10 et j dans 1..20 par v1[i][j].
• v2 : array [1..10, 1..20] of real -> Tableau de 10 * 20 réels. On accède à l'élément d'indice i dans 1..10 et j dans 1..20 par v2[i,j].

VAR v2  :  array  [1..10,  1..20]  of  real;
    i,  j  :  integer;
BEGIN 
 for  i  :=  1  to  10  do 
    for  j  :=  1  to  20  do
      	v2[i,j]  :=  0.0;  
END. 
						      

V.2.2. Tableaux de record

PROGRAM Ecole; 
  CONST MaxEleves  =  35; 
        MaxNotes	=  10;
  TYPE note_t  =  array  [1..MaxNotes] of  real; 
       eleve_t  =  Record
                    age,  nb_notes  :  integer; 
                    notes  :  note_t; 
                    moyenne  :  real; 
                  End; 
	   classe_t  =  array  [1..MaxEleves] of  eleve_t;
  VAR c  :  classe_t; 
	  nb_eleves, i,  j  :  integer; 
BEGIN
   {  ...  } 
for  i  :=  1  to  nb_eleves do 
  begin
    writeln  ('Eleve n.',  i); 
    writeln  ('   age	:  ',  c[i].age);
    write	('   notes  :');
    for  j  :=  1  to  c[i].nb_notes do
      write  ('  ',  c[i].notes[j]);
    writeln;
	writeln  ('   moy	:  ',  c[i].moyenne);
   end;
END. 

• On a comme d'habitude le droit de faire une copie globale entres variables du même type :

VAR  c1,  c2  :  classe_t; 
    e  :  eleve_t;   
    i,  j  :  integer; 
BEGIN
  {  copie  globale de  type  classe_t  } 
  c2  :=  c1; {  échange  global de  type  eleve_t  } 
  e  :=  c1[i];  
  c1[i]  :=  c1[j]; 
  c1[j]  :=  e; 
END. 

• Exemple de passages de paramètres : on écrit une procédure affichant un eleve_t.

PROCEDURE affi_eleve  (e  :  eleve_t); 
 VAR  j  :  integer; 
BEGIN 
  writeln  ('   age	:  ',  e.age);
  write	('   notes  :  ');
  for  j  :=  1  to  e.nb_notes do  
	  write  (e.notes[j]);
  writeln;
  writeln('   moy	:  ',  e.moyenne);
END;	
BEGIN 
 {  ...  }
 for  i  :=  1  to  nb_eleves do
 begin 
   writeln('Eleve n.',  i);
   affi_eleve  (c[i]);
   end; 
 END. 

PROCEDURE affi_classe  (c  :  classe_t  ;  nb  :  integer);
  VAR  i  :  integer; 
BEGIN 
 for  i  :=  1  to  nb  do
 begin
   writeln  ('Eleve n.',  i); 	
   affi_eleve  (c[i]);  
   end; 
END; 
BEGIN
  {  ...  } 
  affi_classe  
  (c,  nb_eleves);
END.
			       

V.3. Le type string

V.3.1. Principe

  VAR  s  :  string[80]; 
BEGIN
 s  :=  'Le  ciel  est  bleu.'; 
 writeln  (s); 
END. 
			          

• Affecter une chaîne plus longue que l'espace réservé à la déclaration est une erreur.
• Comme la longueur courante est codée sur un char, elle est limitée à 255.

V.3.2. Opérateurs sur les strings

  CONST   Slogan  =  'lire  la  doc';
  VAR     s1,  s2  :  string[100];
          i  :  integer;
BEGIN
 s1  :=  'veuillez  ';
 s2  :=  s1  +  Slogan; 
 writeln('s2  =  ''',  s2,  ''''); 
 writeln('Longueur courante de  s2  :  ',  length(s2)  ); 
 write  ('Indices des  ''l''  dans  s2  :  '); 
 for  i  :=  1  to  length(s2) do 
   if  s2[i]  =  'l'  then  
      write(i,  '  '); 
 writeln; 
END. 

b  :=  'A  la  vanille'  <  'Zut';{  vrai  }
b  :=  'bijou'  <  'bidon';{  faux,  c'est  >  car  'j'  >  'd'  }
b  :=  'Bonjour'  =  'bonjour';	{  faux,  c'est  <  car  'B'  <  'b'  }
b  :=  '  zim  boum'  >  'attends  !';	{  faux,  c'est  <  car  '  '  <  'a'  }
	

CONST longStringMax  =  4096;
TYPE   LongString  =  record;
                       c  :  array  [1..LongStringMax] of  char;
		               l  :  interer;  {  longueur courante  }  
                      end; 

FUNCTION longueur(s1  :  LongString  )  :  integer;
FUNCTION est_inferieur  (s1,  s2  :  LongString  )  :  boolean; 
FUNCTION est_egal  (s1,  s2  :  LongString  )  :  boolean; 
PROCEDURE concatene  (s1,  s2  :  LongString  ; var  s3  :  LongString); 

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;