On peut ranger les instructions et les expressions d'entrée/sortie en 3 catégories :
Comme toute variable, une variable de type file of T (cfr Ch 5.3) doit être initialisée. L'initialisation d'une telle variable a pour but d'ouvrir le fichier et de spécifier l'emploi ultérieur qui en sera fait : soit la lecture de données, soit l'écriture des résultats. Il n'est donc pas possible d'écrire dans un fichier ouvert en lecture ou de lire dans un fichier ouvert en écriture. Il n'est pas non plus possible d'ouvrir un fichier á la fois en lecture et en écriture, ce qui est une limitation du PASCAL. En Turbo-PASCAL, il faut avant tout établir une association entre un nom de fichier logique, utilisé dans le texte du programme et un nom de fichier physique, qui est le nom du fichier sur le disque. ( Dans les autres compilateur PASCAL, le nom logique et le nom physique sont les mêmes ). Cette association se fait au moyen de l'instruction :
Les instructions d'initialisation d'un fichier f de type file of T sont les suivantes :
Lorsqu'un fichier f de type file of T a été ouvert en lecture au moyen de l'instruction
reset(f) ( ou aussi rewrite(f) en Turbo-PASCAL )on peut en lire les éléments un á un par une successsion d'instructions
read(f,x)où x est une variable de type T' et où T est affectable á T'. L'effet est de lire un élément du fichier et d'assigner la valeur lue á la variable x. Il est possible de lire plusieurs éléments par une seule instruction read á condition d'énumérer la liste des variables comme argument.
Exemple
read(f,a,b,c)
a le même effet que la suite d'instructions
read(f,a);
read(f,b);
read(f,c);
Lorsqu'un fichier f de type file of T a été ouvert en écriture au moyen de l'instruction
rewrite(f) ( ou aussi rewrite(f) en Turbo-PASCAL )on peut y écrire des éléments un á un par une succession d'instructions
write(f,e)où e est une expression affectable á une variable de type T. En PASCAL standard, e peut être un expression; en Turbo-PASCAL, e ne peut être qu'une variable.
Exemples
write(f,a+1)
write(a)
Il est possible d'écrire plusieurs éléments par une seule instruction write.
write(f,a,b,c)
a le même effet que la suite d'instructions :
write(f,a);
write(f,b);
write(f,c);
Pour lire complètement un fichier de données f, il faut autant d'instructions
read(f,x)qu'il y a d'éléments dans le fichier. Le nombre d'éléments n'étant pas toujours connu á l'avance, il faut disposer d'un moyen de détection de fin de fichier. La fonction booléenne prédéfinie "end of file"
eof(f)renvoie la valeur vrai lorsque tous les éléments du fichier f ont été lus et renvoie faux autrement. En particulier, si le fichier f est initialement vide, eof(f) vaut vrai après l'initialisation du fichier par l'instruction reset(f). Toute tentative de lecture alors que eof(f) est égale á vrai se solde par une erreur á l'exécution et l'arrêt du programme.
Exemple
reset(f);
...
while not eof(f) do
begin
read(f,x);
...
end;
Soit f un fichier de type file of T où T est de type quelconque sauf char. Il n'est pas possible d'éditer, de visualiser ou d'imprimer un tel fichier. En effet, les éditeurs, les imprimantes et les terminaux manipulent uniquement des caractères. Or, un fichier file of integer ne contient pas de caractères, mais bien des nombres entiers représentés de façon binaire. C'est pourquoi on n'utilisera un fichier file of T (avec T char) que lorsque seuls des programmes PASCAL y accèdent en écriture ou en lecture. Tous ces programmes doivent déclarer le fichier f comme étant du type file of T. Dans tous les autres cas, on a recours aux fichiers de type text.
Text est un type prédéfini (cfr Ch 2.2.4).
Un fichier de type text se compose d'une suite de lignes, chacune d'entre elles étant une suite de caractères. La fin d'une ligne est indiquée par le caractère spécial "retour chariot" (en anglais "carriagereturn").
L'initialisation d'un fichier de type text suit le schéma
d'initialisation d'un fichier de type file of T.
Pour rappel :
reset(f)on peut y lire les éléments un á un par une succession d'instructions
read(f,x)où, en PASCAL standard, x est une variable d'un des types simples sauf un type énuméré ou le type Boolean, c'estádire : char, integer, real, intervalle (cfr Ch 2.1) ou un synonyme de ceuxci (cfr Ch 4.3). Remarque : x ne peut donc pas être une chaîne de caractères (packed array [...] of char). Mais en Turbo-PASCAL, x peut être d'un type string ( cfr Manuel de Référence du Turbo-PASCAL).
Plus précisément,
read(f,x)est de lire une suite de caractères qui représente ce nombre, de la convertir automatiquement en une valeur dont le type doit être affectable au type de x et d'assigner cette valeur á x. En cas d'erreur de conversion, le programme s'arrête avec un message d'erreur.
read(f,x)est de lire un seul caractère, les séparateurs étant considérés comme des caractères á part entière.
Remarque : le PASCALUVA permet l'écriture de valeurs de type booléen. Les règles s'appliquant á la lecture d'un nombre sont d'application. Si une valeur lue n'appartient pas au type attendu, une erreur est générée. Les suites de caractères représentant les valeurs booléennes sont TRUE et FALSE (en majuscules).
Note importante : la différence de comportement avec la situation décrite au § 1.2 du présent chapitre peut être résumée comme suit :
L'effet de l'instruction
readln(f)est de forcer le passage á la ligne: tous les caractères, depuis celui qui suit le dernier caractère lu jusqu'au caractère retour chariot suivant, sont sautés, retour chariot compris. Ceci permet de se positionner au début de la ligne suivante. 2.3.3. Instruction readln(f,x)
L'instruction
readln(f,x)est équivalente á la suite d'instructions
read(f,x);
readln(f)
2.3.4. Lecture groupéeIl est possible de lire plusieurs éléments par une seule instruction read ou readln á condition d'énumérer la liste des variables comme argument.
Exemple
read(f,a,b,c)a le même effet que la suite d'instructions
read(f,a);
read(f,b);
read(f,c);
et l'instruction
readln(f,a,b,c)a le même effet que la suite d'instructions
read(f,a);
read(f,b);
readln(f,c);
Lorsqu'un fichier de type text a été ouvert en écriture au moyen de l'instruction
rewrite(f)on peut y écrire des éléments un á un par une succession d'instructions
write(f,e)où e est une expression de type char, integer, real, intervalle d'un de ces types, ou un packed array of char (cfr Ch 2.2.1.2) ou un synonyme de ceuxci (cfr Ch 4.3). Plus précisément, l'expression est convertie en une suite de caractères représentant la valeur de l'expression; c'est cette suite de caractères qui est écrite dans le fichier. Remarque : le Turbo-PASCAL permet l'écriture de valeurs de type booléen. Les suites de caractères représentant les valeurs booléennes sont True et False.
Exemple
write(f,a+1) ;
write(´Braine l´´Alleud´) ;
write(f,b) ;
write(f,sqrt(b)) ;
2.4.2. Instruction writeln(f)L'effet de l'instruction
writeln(f)est de passer á la ligne suivante dans le fichier résultat (en fait, il y a écriture du caractère "retour chariot" dans le fichier). 2.4.3. Instruction writeln(f,x)
L'instruction
writeln(f,x)est équivalente á la suite d'instructions
write(f,x);
writeln(f)
2.4.4. Ecriture groupéeIl est possible d'écrire plusieurs éléments par une seule instruction write ou writeln á condition d'énumérer la liste des variables comme argument.
Exemple
write(f,a,b,c)a le même effet que la suite d'instructions
write(f,a);
write(f,b);
write(f,c);
et l'instruction
writeln(f,a,b,c)a le même effet que la suite d'instructions
write(f,a);
write(f,b);
writeln(f,c);
On utilise la fonction booléenne eof(f) comme décrit en Ch 10.1.4. Pour rappel, la fonction eof(f) renvoie la valeur vrai lorsque tous les éléments du fichier f ont été lus et renvoie faux sinon. En particulier, si le fichier f est initialement vide, eof(f) vaut vrai après l'initialisation du fichier par l'instruction reset(f). Toute tentative de lecture alors que eof(f) est égal á vrai se solde par une erreur á l'exécution du programme et un arrêt de celuici.
Exemple
Voici un exemple de fragment de programme correct:
reset(f);
...
while not eof(f) do
begin
read(f,x);
...
end;
La fonction booléenne "end of line"
eoln(f) (où f est de type text)renvoie la valeur vrai lorsque tous les éléments "utiles" d'une ligne ont été lus (c'estádire lorsque le prochain caractère á lire est le caractère retour chariot) et renvoie la valeur faux autrement.
eof(f) est vraialors
eoln(f) est vrai également( Ce comportement est propre au Turbo-PASCAL, en PASCAL standard, la valeur de eoln(f) devrait alors être indéfinie).
Exemple
begin
reset(f);
while not eof(f) do
begin
while not eoln(f) do
begin
read(f,x);
...
end; {while not eoln}
readln(f) {lire le retour chariot}
end; {while not eof}
end;
Le nombre de caractères écrits varie selon le type de la valeur écrite; en PASCALUVA, il varie de la manière suivante :
char 1
Boolean 4 si la valeur est TRUE
5 si la valeur est FALSE
integer 10
real 15
string nombre de caractères du type
Il est possible, en PASCAL, de préciser explicitement le nombre
de caractères á écrire lors d'un ordre write.
Il faut, pour cela, faire suivre l'expression dont on veut
imprimer la valeur de paramètres de contrôle, précédés du caractère ':'.
L'ordre d'écriture est alors
write(fff,e:longueur)ou
write(fff,e:longueur:fract) (uniquement pour le type real)Les deux paramètres longueur et fract sont des nombres (valeurs ou identificateurs de constante) entiers positifs.
write(fff,e:longueur) <=> begin
for i := 1 to longueur-1 do write(fff,´ ´);
write(fff,e)
end
write(fff,e:longueur) <=> begin
for i := 1 to longueur - L do write(fff,´ ´);
i := 1;
while (i <= longueur) and (i <= L) do
begin
write(fff,e[i]);
i := i+1
end {while}
end
où e[i] représente le ième caractère du string e.
write(fff,e:longueur) <=> if e then write(fff,´TRUE´:longueur)
else write(fff,´FALSE´:longueur)
où 'TRUE' et 'FALSE' sont des strings de longueurs
respectives 4 et 5.
write(fff,e:longueur) <=> begin
for i := 1 to longueur - n do write(fff,´ ´);
ecrire les n caracteres de la representation decimale de e
end
La valeur sera donc toujours imprimée correctement, quitte á
ne pas respecter le format demandé par l'utilisateur.
Sinon, write(fff,e:longueur:fract) <=> write(fff,e:longueur).Il est impossible de représenter e en point fixe si
abs(e) + (0.5 * 10**(-fract)) (valeur arrondie)étant donné que 16 est le nombre de chiffres significatifs de tout réel en PASCALUVA.
Les fichiers de nom input et output représentent respectivement l'entrée et la sortie standard (cfr Ch 5.3). Ces fichiers sont en fait de type text. Lorsqu'on souhaite les utiliser, ils doivent figurer dans l'entête mais ne doivent pas être déclarés dans la partie déclaration de variables.
Les instructions de lecture sont
read(x) (lecture d'un élément)
readln (passage á la ligne)
readln(x) (combinaison des deux instructions précédentes)
read(a,b,c) (lectures groupées)
readln(a,b,c) (lectures groupées)
De même les instructions d'écriture sont :
write(x) (écriture d'un élément)
writeln (passage á la ligne)
writeln(x) (combinaison des deux instructions précédentes)
write(a,b,c) (écritures groupées)
writeln(a,b,c) (écritures groupées)
Elles ont le même effet que les instructions décrites en
Ch 10.2.3
et Ch 10.2.4,
ces dernières s'appliquaient au
fichier de type text. A noter ici qu'on n'indique pas le nom du
fichier utilisé en argument (par exemple, on n'écrit ni
write(output,x), ni read(input,x)).
Les fonctions booléennes de détection de fin de ligne et de fin
de fichier sont
eoln
eof
Elles ont le même effet que celles décrites au
Ch 10..2.5
et Ch 10.2.6.
A noter ici qu'on n'indique pas non plus le nom
du fichier input en argument.
Exemple
begin
while not eof do
begin
while not eoln do
begin
read(x);
...
end; {while not eoln}
readln
end {while not eof}
end;
___________________________________________________________________________
| | input | text | file of T |
| | output | | |
|_______________|__________________|____________________|__________________|
|le nom doitil | oui | oui (externe) | oui (externe) |
|figurer | | | |
|dans l'entête | | non (interne) | non (interne) |
|du programme ? | | | |
|_______________|__________________|____________________|__________________|
|le nom du | non | oui | oui |
|fichier doit | | | |
|il être | | | |
|déclaré ? | | | |
|_______________|__________________|____________________|__________________|
|initialisation | | assign(f,'...') | assign(f,'...') |
|du fichier | | reset(f) | reset(f) |
| | | rewrite(f) | rewrite(f) |
|_______________|__________________|____________________|__________________|
|lecture | read(x) | read(f,x) | read(f,x) |
| | readln | readln(f) | |
| | readln(x) | readln(f,x) | |
| | read(a,b,...) | read(f,a,b,...) | read(f,a,b,...) |
| | readln(a,b,...) | readln(f,a,b,...) | |
|_______________|__________________|____________________|__________________|
|écriture | write(x) | write(f,x) | write(f,x) |
| | writeln | writeln(f) | |
| | writeln(x) | writeln(f,x) | |
| | write(a,b,...) | write(f,a,b,...) | write(f,a,b,...) |
| | writeln(a,b,...) | writeln(f,a,b,...) | |
|_______________|__________________|____________________|__________________|
|test de fin de | eof | eof(f) | eof(f) |
|fichier | | | |
|_______________|__________________|____________________|__________________|
|test de fin de | eoln | eoln(f) | |
|ligne | | | |
|_______________|__________________|____________________|__________________|
où ``externe'' (resp. ``interne'') signifie ``pour les fichiers
externes (resp. internes)''.
