Le mot informatique est un mot français ("computer science" en anglais) désignant la science qui traite des données pour obtenir des informations (résultats). Ce traitement est traditionnellement effectué à l'aide d'algorithmes.
Un algorithme est une suite d'opérations à effectuer pour résoudre un problème.
L'algorithmique est la partie de l'informatique qui traite des algorithmes.
Exemples d'algorithmes:
- Un algorithme de résolution de l'équation ax+b = 0 est:
1. Soustraire b à gauche et à droite du signe =. On obtient ax = -b
2. Si a est non nul diviser chaque membre par a. On obtient le résultat cherché qui est x = -b/a 3. Si a est nul l'équation est insoluble
- Un algorithme de mise en marche d'une voiture est:
1. Mettre la clé dans le démarreur
2. Serrer le frein à main
3. Mettre le levier des vitesses au point mort
4. Répéter les opérations suivantes
- tourner la clé dans le sens des aiguilles d'une montre
- attendre quelques secondes
- mettre la clé dans la position "marche"- si le moteur ne tourne pas, ramener la clé dans sa position initiale jusqu'à ce que le moteur démarre
5. Enclencher la première vitesse
6. Desserrer le frein à main
Lorsqu'un ordinateur doit suivre un algorithme pour résoudre un problème, cet algorithme doit être exprimé dans un langage compréhensible par la machine. Ce langage appelé langage machine est composé de suites de 0 et de 1.
Or le programmeur ne peut exprimer des algorithmes complexes avec des 0 et des 1! Il va utiliser un langage plus proche d'une langue naturelle et appelé langage de programmation.
Un fois cet algorithme codé dans un langage de programmation le programme ainsi créé doit être
- soit traduit complètement en langage machine par le compilateur - soit directement interprété, c'est-à-dire que chaque ligne de code est exécutée directement sans une traduction de tout le programme. Cette ligne peut ou non être traduite en un langage proche du langage machine avant exécution.
La compilation est une étape supplémentaire mais a l'avantage de produire un programme en langage machine. Ce programme en langage machine peut exister aussi longtemps que nécessaire. Chaque fois que le programme doit être utilisé, il le sera directement, ce qui implique que la compilation n'est nécessaire que la première fois.
L'interprétation est plus directe mais la traduction de chaque ligne a lieu à chaque utilisation du programme.
L'exécution par un ordinateur d'un programme compilé sera donc nettement plus rapide que l'exécution d'un programme par interprétation.
Enfin la programmation est la technique utilisée pour écrire des programmes en langage de programmation.
[ Retour à la table des matières ]
Voici par ordre chronologique les principaux langages de programmation utilisés aujourd'hui ainsi que leur principal domaine d'application:
Année Langage Domaine d'application Remarques
1955 Fortran Calcul scientifique Langage ancien, dont les versions plus récentes comportent des bizarreries héritées des années 50! 1958 Algol-60 Algorithmique Premier langage algorithmique
1959 Lisp Intelligence artificielle Premier langage non traditionnel
1961 Cobol Gestion Langage "verbeux", peu maniable
1964 PL/1 Langage général Complexe, créé et utilisé chez IBM 1965 Basic "Travail à la maison" Simple d'utilisation, peu adapté à la programmation structurée 1970 Prolog Intelligence artificielle Langage non algorithmique 1971 Pascal Enseignement Créé à Zurich, diffusé partout, souffre des nombreuses versions différentes d'un ordinateur à l'autre 1972 C Programmation système Accès facile au matériel 1980 Modula-2 Programmation système Descendant direct de Pascal, mêmes problèmes de versions différentes 1983 Ada Langage général Complexe, puissant, langage du futur?
Mentionnons également les langages d'assemblage appelés assembleurs, utilisés surtout pour programmer au niveau de la
machine.
[ Retour à la table des matières ]
1.3 Qu'est-ce qu'un ordinateur?
Un ordinateur est une machine créée pour exécuter très rapidement et de manière très fiable des tâches complexes. C'est un assemblage de composants matériels et logiciels. Le matériel (hardware en anglais) comporte toutes les parties physiques alors que le logiciel (software en anglais) représente tous les programmes nécessaires au fonctionnement du matériel.
Le matériel peut être schématisé ainsi:
Le logiciel peut se représenter de la manière suivante:
L'apparence externe d'un ordinateur est très variable (observer un Macintosh, un Olivetti M250, un Vax, un Cray ). Tous sont cependant formés des éléments cités ci-dessus.
[ Retour à la table des matières ]
Les ordinateurs actuels peuvent être classés en 5 catégories selon leurs domaines d'application:
a) Supercalculateurs (et non superordinateurs!)
Machines destinées au calcul scientifique, extrêmement rapides.
Exemples typiques: Cray-YMP, NEC
Machines destinées au calcul scientifique et aux applications de gestion.
Exemples typiques: IBM AS/400, Vax 9000, Burroughs
Machines de développement, CAO.
Exemples typiques: DEC Vax 6000-510, Data General série MV, HP 9000 d) Stations individuelles
CAO, commande de processus, machines de développement.
Exemples typiques: Sun 3, Sun SPARC, Apollo
Apprentissage, machines de bureau, commande de processus.
Exemples typiques: Macintosh SE/30, IBM PS/2, machines à base de 386 et 486
Remarque importante:
Chaque ordinateur est adapté à une (ou quelques) catégorie(s) d'applications mais aucun ne pourra convenir agréablement à plusieurs applications fondamentalement différentes.
[ Retour à la table des matières ]
L'expérience montre que le premier langage appris est fondamental pour le futur d'un programmeur. En effet les habitudes prises sont ancrées si profondément qu'il est très difficile de les modifier voire de s'en défaire!
L'apprentissage de la programmation doit donc s'effectuer avec un langage forçant le programmeur à adopter de "bonnes habitudes" (cf. 1.6).
D'autre part il est toujours plus facile d'apprendre et d'utiliser de nouveaux langages lorsque ces "bonnes habitudes" sont acquises.
Le langage Pascal aide à l'apprentissage d'une bonne programmation en obligeant le programmeur à se soumettre à certaines contraintes et en lui fournissant une panoplie assez riche d'outils agréables à utiliser.
Ces outils vont permettre de coder relativement simplement un algorithme pas trop complexe, de refléter fidèlement sa structure.
[ Retour à la table des matières ]
Le but de tout programmeur est d'écrire des programmes justes, simples, lisibles par d'autres programmeurs, fiables et efficaces. Pour cela les quelques points suivants sont fondamentaux (liste non exhaustive!):
1. Réfléchir et imaginer de bons algorithmes de résolution avant d'écrire la première ligne du programme.
2. Une fois l'algorithme trouvé, en écrire l'esquisse en français, puis le coder dans le langage de programmation choisi.
3. Lors du codage:
- choisir des noms parlants pour représenter les objets
manipulés dans le programme
- commenter chaque morceau du programme de manière explicative et non descriptive
- tester chaque module, procédure, fonction séparément
[ Retour à la table des matières ]
Voici une marche à suivre pour la création de programmes à partir d'un problème donné.
1. Bien lire l'énoncé du problème, être certain de bien le comprendre.
2. Réfléchir au problème, déterminer les points principaux à traiter.3. Trouver un bon algorithme de résolution (cf. 2.2), l'écrire sur papier et en français. 4. Coder l'algorithme en un programme écrit sur papier.
5. Introduire le programme dans l'ordinateur au moyen d'un éditeur.
6. Vérifier la syntaxe du programme au moyen d'un vérificateur de syntaxe.
7. Compiler (puis linker) le programme
8. Exécuter le programme, vérifier son bon fonctionnement par des tests
En cas d'erreurs de syntaxe ou d'erreurs à la compilation il faut les corriger avec l'éditeur puis reprendre au point 6.
Si le programme fonctionne mais donne des résultats faux, cela signifie qu'il y a des erreurs de logique. Il faut réfléchir, les trouver, modifier le programme en conséquence puis reprendre au point 6.
[ Retour à la table des matières ]
CHAPITRE 2
2.1 Exemple introductif
Nous allons examiner un problème (simple) dont la résolution sera effectuée en respectant la marche à suivre donnée au chapitre 1 (cf. 1.7), restreinte aux points 1 à 4. Pour trouver un algorithme de résolution (points 2 et 3) nous allons appliquer une méthode qui devrait être utilisée chaque fois qu'un problème de programmation doit être résolu. Cette méthode est connue sous le nom de méthode de décomposition par raffinements successifs.
Nous allons également nous baser sur cet exemple pour rappeler des bonnes habitudes de programmation et pour introduire les premières notions de programmation en langage Pascal.
L'exemple est le suivant:
Dessiner sur l'écran du Macintosh une figure composée de deux formes géométriques (carré, triangle isocèle), chacune comportant son nom en forme de titre.
Sans être trop optimiste la compréhension de ce problème est immédiate, après avoir précisé que la disposition des formes est libre et qu'un titre doit se situer au-dessus de "sa" forme (point 1 résolu).
[ Retour à la table des matières ]
2.2 Méthode de décomposition par raffinements successifs
Cette méthode est basée sur l'idée suivante:
Etant donné un problème, le décomposer en sous-problèmes de telle manière que
- chaque sous-problème soit une partie du problème donné
- chaque sous-problème soit plus simple (à résoudre) que le problème donné- la réunion de tous les sous-problèmes soit équivalente au problème donné
puis reprendre chaque sous-problème et le décomposer comme ci-dessus. Une étape de cette suite de décompositions est appelée raffinement.
Cette méthode est efficace après l'avoir utilisée plusieurs fois. Elle est indispensable lorsque les problèmes deviennent complexes. Cependant son application dans des cas simples donne de bons algorithmes de résolution des problèmes.
[ Retour à la table des matières ]
2.3 Application à l'exemple introductif
2.3.1 Considérations techniques
Selon le point 2 de la marche à suivre (cf. 1.7) il faut déterminer les points principaux à traiter. Notre problème étant géométrique, il faut tout d'abord connaître la "surface de dessin" à savoir l'écran du Macintosh.
La documentation technique nous apprend que:
- l'écran du Macintosh est une grille de 512x342 points
- Le dessin s'effectue dans la fenêtre de dessin (Drawing)
- le système de coordonnées (cartésiennes) a son origine au point (0, 0) situé en haut à gauche de la fenêtre de dessin
- les axes sont disposés ainsi:
Ceci établi nous pouvons remarquer qu'il faudra:
- connaître comment faire apparaître la fenêtre de dessin;
- savoir dessiner un carré et un triangle, ou au moins des segments;- également savoir dessiner (écrire) un texte.
Ces renseignements constituent le point 2 de la marche à suivre.
[ Retour à la table des matières ]
2.3.2 Algorithme de résolution
L'algorithme de résolution (point 3, cf. 1.7) va être déterminé en utilisant notre méthode. Etant donné le problème initial, on en extrait les sous-problèmes
a. ouvrir (faire apparaître) la fenêtre de dessin
b. dessiner le carré et son titre
c. dessiner le triangle isocèle et son titre
Ceci constitue le premier raffinement. Comme le point a est immédiatement traduisible en Pascal Macintosh, laissons-le tel quel. Le raffinement suivant est alors:
a. ouvrir (faire apparaître) la fenêtre de dessin
b.1 dessiner le titre CARRE
b.2 dessiner le carré avec les côtés parallèles aux axes de coordonnées
c.1 dessiner le titre TRIANGLE
c.2 dessiner le triangle isocèle sur la pointe, avec la base parallèle à l'axe des x
Afin de présenter un troisième raffinement, nous supposons que Pascal Macintosh ne permet pas de dessiner directement un carré ou un triangle. On a donc:
a. ouvrir (faire apparaître) la fenêtre de dessin
b.1.1 choisir la position du titre (coin en bas à gauche de la première lettre): (30, 100)
b.1.2 dessiner le mot CARRE depuis cette position
b.2.1 choisir la position du carré (sommet en haut à gauche): (30, 120)
b.2.2 dessiner le côté supérieur depuis cette position
b.2.3 dessiner le côté droit depuis l'extrémité droite du côté supérieur
b.2.4 dessiner le côté inférieur depuis l'extrémité inférieure du côté droit
b.2.5 dessiner le côté gauche depuis l'extrémité gauche du côté inférieur
c.1.1 choisir la position du titre (coin en bas à gauche de la première lettre): (110, 100)
c.1.2 dessiner le mot TRIANGLE depuis cette position
c.2.1 choisir la position du triangle isocèle (sommet gauche): (110, 120)
c.2.2 dessiner la base depuis cette position
c.2.3 dessiner le côté droit depuis l'extrémité droite de la base
c.2.4 dessiner le côté gauche depuis l'extrémité inférieure du côté droit
Cette suite de raffinements s'arrête ici. En effet Pascal Macintosh offre les moyens de
- dessiner un segment (côté) depuis un point courant (une extrémité)
- dessiner un mot (titre)
La suite d'opérations a, b.1.1, b.1.2, , c.2.4 est un algorithme de résolution du problème donné, écrit en français (point 3 résolu).
[ Retour à la table des matières ]
2.3.3 Codage de l'algorithme en Pascal
Le premier essai de codage de l'algorithme en Pascal (point 4, cf. 1.7) nous donne le programme suivant:
program exemple_essai_1 (input, output); begin showdrawing; moveto (30, 100); drawstring ('CARRE'); moveto (30, 120); line (50, 0); line (0, 50); line (- 50, 0); line (0, - 50); moveto (110, 100); drawstring ('TRIANGLE'); moveto (110, 120); line (80, 0); line (- 40, 40); line (- 40, - 40); end.
Ce programme est correct, simple, fonctionne parfaitement mais est horriblement malécrit. En effet il faut savoir ou se rappeler que
- un programme doit être lisible, ce qu'il n'est pas
- un programme doit être commenté, ce qu'il n'est pas
- un programme doit refléter les décisions prises par le programmeur (icigrandeur des dessins, points initiaux des dessins) - les nombres entiers peuvent signifier n'importe quoi! Il faut préciser leur signification en leur substituant des noms parlants.
Après avoir tenu compte de ces remarques, un bon programme est:
program exemple_bien_fait (input, output);
(* Auteur : Dupont Jean ET1 *)
(* Date : 10 novembre 1987 *)
(* Pour la suite, voir le document "Présentation des *) (* programmes" *)
const droite = 1; (* pour se déplacer d'une unité *) gauche = -1; (* dans les quatre directions *) haut = -1; bas = 1; a_l_horizontale = 0; (* Pour un trait vertical, le *) (* déplacement horizontal est nul *) a_la_verticale = 0; (* Pour un trait horizontal, le *) (* déplacement vertical est nul *) demi_base = 40; (* longueur de la demi-base du *) (* triangle *) cote_carre = 50; (* longueur d'un côté du carré *) distance = 20; (* distance titre - forme dessinée *)
var abscisse_titre_carre : integer; (* abscisse et ordonnée du point *) ordonnee_titre_carre : integer; (* initial de dessin du titre CARRE *) abscisse_titre_triangle : integer; (* abscisse et ordonnée du point *) ordonnee_titre_triangle : integer; (* initial du titre TRIANGLE *)
begin (* exemple_bien_fait *)
(* Présentation du programme, en commençant par ouvrir la fenêtre de texte *) showtext; writeln ( 'Bonjour. Je vais dessiner un carre et un triangle avec leur titre.' );
(* L'utilisateur donne le point initial de dessin du carré *) write ( 'Donnez l''abscisse puis l''ordonnee du point initial du carre:' ); readln ( abscisse_titre_carre, ordonnee_titre_carre );
(* Ecriture du titre du dessin du carré, après ouverture de la fenêtre de dessin *) showdrawing;
moveto ( abscisse_titre_carre, ordonnee_titre_carre ); drawstring ( 'CARRE' );
(* Dessin du carré *)
moveto ( abscisse_titre_carre, ordonnee_titre_carre + distance * bas ); line ( cote_carre * droite, a_l_horizontale ); line ( a_la_verticale, cote_carre * bas ); line ( cote_carre * gauche, a_l_horizontale ); line ( a_la_verticale, cote_carre * haut );
(* L'utilisateur donne le point initial de dessin du triangle *) write ( 'Donnez l''abscisse puis l''ordonnee du point initial du triangle:' ); readln ( abscisse_titre_triangle, ordonnee_titre_triangle );
(* Ecriture du titre du dessin du triangle *)
moveto ( abscisse_titre_triangle, ordonnee_titre_triangle ); drawstring ( 'TRIANGLE' );
(* Dessin du triangle *) moveto ( abscisse_titre_triangle, ordonnee_titre_triangle + distance * bas ); line ( 2 * demi_base * droite, a_l_horizontale ); line ( demi_base * gauche, demi_base * bas ); line ( demi_base * gauche, demi_base * haut );
end.
[ Retour à la table des matières ]
2.4 Structure d'un programme Pascal
Un programme Pascal est composé de trois parties principales:
- l'en-tête du programme où sont spécifiés le nom du programme ainsi que les fichiers externes utilisés (cf. 10.3.5). L'en-tête est toujours accompagné d'un commentaire précisant le nom de l'auteur, la date de création (cf. document "Présentation des programmes").
Exemple:
program exemple_bien_fait (input, output); (* Auteur : Dupont Jean ET1 *)
(* Date : 10 novembre 1986 *)
(* *)
- la partie déclarative contenant les déclarations des objets (constantes, variables, ) utilisés dans le programme. Ces objets représenteront les données traitées par le programme.
Notons que les constantes doivent être déclarées avant les variables.
- le corps du programme, compris entre les mots begin et end. Ce corps contient les instructions du programme, c'est-à-dire les actions à entreprendre sur les données. C'est principalement dans le corps que se retrouve l'algorithme choisi pour écrire le programme.
[ Retour à la table des matières ]
2.5 Constituants d'un programme
2.5.1 Généralités
Un programme est écrit dans un langage (de programmation). Ce langage est composé de mots, symboles, commentaires Ceux-ci sont groupés en phrases (dont l'ensemble compose le programme) qui obéissent à des règles. Ces règles déterminent de manière absolument stricte si une phrase est correcte ou non (respect de la syntaxe).
L'analogie avec les langues naturelles (français, allemand ) est donc forte, la principale différence étant qu'une phrase française peut être formée de manière beaucoup moins rigoureuse et signifier néanmoins quelque chose. Or une phrase en Pascal doit être absolument juste pour être comprise par le compilateur ou l'interprète, sans quoi elle est obligatoirement rejetée!
Un programme Pascal est composé de phrases appelées unités syntaxiques. Elles sont elles-mêmes constituées de mots, symboles
appelés unités lexicales. Chaque unité lexicale est une suite de caractères appartenant au jeu de caractères Pascal.
[ Retour à la table des matières ]
2.5.2 Le jeu de caractères Pascal
Le jeu de caractères Pascal comporte les caractères donnés par l'annexe B. Ajoutons que les constantes caractère et chaînes de caractères (cf. 2.5.3) peuvent être formées de n'importe quel caractère ASCII (cf. annexe A) imprimable.
[ Retour à la table des matières ]
2.5.3 Les unités lexicales de Pascal
Les unités lexicales en Pascal sont:
- les identificateurs, comme par exemple a, limite_100, cote_carre, write Un identificateur est un mot composé de lettres, de chiffres et du caractère "_" et commençant obligatoirement par une lettre. S'il n'y a aucune limite théorique au nombre de caractères composant un identificateur, tous les compilateurs imposent cependant un nombre maximal (par exemple Pascal Macintosh: 255, Pascal VAX : 31).
Le langage contient des identificateurs prédéfinis comme write, writeln, integer que le programmeur peut éventuellement redéfinir mais dont le but principal reste d'être utilisés tels quels dans différentes situations. L'annexe D en donne la liste.
- les mots réservés (ou mots-clés) qui sont des identificateurs réservés à un usage bien défini (toujours le même!), par exemple program const begin . L'annexe C en donne la liste.
- les symboles formés d'un unique caractère ou de deux caractères accolés, comme ; = ( := <> par exemple. L'annexe B en donne la liste.
- les commentaires, c'est-à-dire n'importe quels caractères entre les symboles (* et *) .
- les constantes numériques (entières ou réelles) comme 1 123 -36
12.3 124e3 -234.0e3 -0.3e-2 (cf. 3.2 et 3.3).
- les constantes caractères, c'est-à-dire un caractère entre apostrophes; par exemple: 'a' '?' 'A' (cf. 4.5).
- les constantes chaînes de caractères, c'est-à-dire une suite de plusieurs caractères entre apostrophes; par exemple 'abcd' 'CARRE' 'triangle de Pascal' (cf. 8.2).
Chaque unité lexicale peut (doit) être séparée des autres par un ou plusieurs espaces, caractères de tabulation ou passages à la ligne (examiner les espaces du programme exemple_bien_faitcf. 2.3.3).
[ Retour à la table des matières ]
2.5.4 Les unités syntaxiques de Pascal et diagrammes syntaxiques
Les unités syntaxiques en Pascal peuvent être décrites par des diagrammes appelés diagrammes syntaxiques. L'annexe G en donne la liste.
Voici l'exemple d'un tel diagramme permettant de vérifier qu'un "mot" est bien un identificateur:
[ Retour à la table des matières ]
2.6 Mise en page
La mise en page d'un programme Pascal est assez libre. Cependant, pour des raisons de clarté, de lisibilité d'un programme il existe des conventions qu'il faut respecter. Elles sont décrites dans le document "Présentation des programmes".
[ Retour à la table des matières ]
CHAPITRE 10
10.1 Motivation
Toutes les structures de données que nous avons vues ont un point commun: elles résident toutes dans la mémoire principale de l'ordinateur. Ceci signifie que l'effacement (volontaire ou non!) de la mémoire provoque la destruction de ces structures, ainsi d'ailleurs que celle du programme Pascal les utilisant.
D'autre part il peut être nécessaire de conserver certaines données après la fin du programme les ayant créées, ceci en prévision d'une utilisation future.
Ces considérations nous amènent à introduire la notion de fichier.
[ Retour à la table des matières ]
10.2 Qu'est-ce qu'un fichier?
Hors du monde informatique un fichier est une collection de fiches; chacun de nous a déjà manipulé un fichier dans une bibliothèque, une administration etc. Ces fichiers se caractérisent par un nombre quelconque de fiches en général toutes de même aspect. Pour trouver une fiche il faut parcourir le fichier fiche après fiche ou utiliser une clé d'accès si le fichier est trié selon cette clé (ordre alphabétique, ordre de cotation des livres ).
En informatique on définit qu'un fichier est une structure de données toutes de même type mais dont le nombre n'est pas connu à priori. L'accès à un élément (à une donnée) du fichier se fait
- séquentiellement c'est-à-dire en parcourant le fichier élément par élément depuis le début jusqu'à l'élément choisi - directement en donnant la position de l'élément cherché
- selon une clé chaque valeur de la clé désignant un élément on obtient ainsi l'élément désiré
Les fichiers sont conservés en mémoire secondaire (disques et bandes magnétiques, disquettes, cassettes ) et subsistent tant que cette mémoire secondaire n'est pas effacée ou endommagée. Chaque fichier est désigné par un nom et possède des attributs tels que date de création, taille, icône (Macintosh)
Ils se répartissent en deux catégories:
1. Les fichiers binaires contenant du code binaire représentant chaque élément (cf. 10.3). Ces fichiers ne doivent être manipulés que par des programmes!
2. Les fichiers de texte (appelés aussi imprimables) contenant des caractères et susceptibles d'être lus, éditées, imprimés (cf.
10.4).
Pascal va permettre de créer et d'utiliser des fichiers à accès séquentiel uniquement. Notons cependant que de nombreuses versions de Pascal offrent des possibilités d'accès direct, voire d'accès par clé.
En particulier : Pascal Macintosh permet l'accès direct, Pascal VAX les accès direct et par clé.
[ Retour à la table des matières ]
10.3 Les types fichier
10.3.1 Généralités
Un fichier (binaire) se déclare au moyen des mots réservés file of. Les types fichier sont structurés, le type de leurs éléments peut être n'importe lequel (sauf un type fichier!). Comme d'habitude une variable fichier sera définie au moyen d'un type fichier.
Exemples:
const long_max_nom = 30; (* pour le type t_auteur_livre *) long_max_titre = 40;
type t_fich_entiers = file of integer; t_fich_reels = file of real;
t_auteur_livre = string [ long_max_nom ]; (* syntaxe Pascal Macintosh! *) t_titre_livre = string [ long_max_titre ];
t_livre_cote = record (* représente une fiche bibliographique *) nom_auteur : t_auteur_livre; titre : t_titre_livre; cote : integer; end; t_fichier_biblio = file of t_livre_cote;
var fichier_reponses : t_fich_entiers; (* fichier dont les éléments seront *) (* tous entiers *)
fichier_mesures : t_fich_reels; (* contient les mesures du 16.2.87 *)
(* de la température diurne (en Co) *)
bibliotheque : t_fichier_biblio; (* ouvrages de la bibliothèque de *) (* l'EINEV jusqu'au 31.12.1990 *)
Il existe un type fichier prédéfini: text(cf. 10.4).
Il existe deux (variables) fichiers prédéfinis: input et output(cf. 10.4) de type text .
La seule opération permise sur les fichiers est le passage en paramètre: un fichier doit toujours être un paramètre d'entrée et de sortie! L'affectation est donc interdite entre fichiers. Notons qu'en général les fichiers sont mentionnés comme paramètres de tout programme les utilisant (cf. 10.3.5).
Les expressions sont réduites aux variables d'un type fichier.
Comme dans le cas des tableaux (cf. 6.3) l'intérêt des fichiers réside en l'utilisation de leurs éléments (cf. 10.3.3). [ Retour à la table des matières ]
10.3.2 Ouverture et fermeture des fichiers
En Pascal un fichier peut être soit lu soit écrit. On dit alors que le fichier est ouvert en lecture respectivement en écriture. Pour utiliser un fichier celui-ci doit donc préalablement être ouvert soit en lecture soit en écriture. Ceci se fait
- par la procédure prédéfinie reset(cf. 10.3.4) pour l'ouverture en lecture
- par la procédure prédéfinie rewrite(cf. 10.3.4) pour l'ouverture en écriture. Notons que l'ouverture en écriture provoque l'initialisation du fichier!
Exemple: var bibliotheque : t_fichier_biblio; (* cf. 10.3.1 *)
begin rewrite ( bibliotheque ); (* initialisation du fichier bibliotheque *)
(* écriture dans le fichier *) reset ( bibliotheque ); (* le fichier bibliotheque va être relu *)
(* lecture du fichier *) end.
La fermeture d'un fichier est faite automatiquement à la fin du programme. Attention cependant à certaines versions de Pascal qui exigent une fermeture explicite, rendant ces fichiers inutilisables par la suite en cas d'oubli! Pascal Macintosh et Turbo Pascal exigent une fermeture avant une réouverture du même fichier dans un autre mode. Cette fermeture s'effectue par la procédure close(cf.
10.3.4).
[ Retour à la table des matières ]
10.3.3 Accès séquentiel aux éléments d'un fichier
L'accès à un élément va consister à le lire ou à l'écrire. Pour faciliter la compréhension il faut s'imaginer que
- une fenêtre est ouverte sur cet élément et en permet l'accès alors que tous les autres sont cachés.
- tout fichier est terminé par une marque de fin de fichier permettant de savoir où se termine le fichier.
L'accès séquentiel est le fait que:
- La lecture d'un élément se fait en parcourant le fichier depuis le début jusqu'à l'élément. La fenêtre désigne alorsl'élément à lire.
- L'écriture d'un élément se fait toujours à la fin du fichier. La fenêtre désigne alors l'endroit où va être écrit l'élément.
Exemple:
var bibliotheque : t_fichier_biblio; (* cf. 10.3.1 *)
alors la fenêtre se note
bibliotheque^
Elle s'utilise comme une variable de type t_livre_cote (cf. 10.3.1). Il est donc autorisé d'accéder aux différents champs ainsi:
bibliotheque^.nom_auteur (* de type t_auteur_livre *) bibliotheque^.titre (* de type t_titre_livre *) bibliotheque^.cote (* de type integer *)
Pour un fichier ouvert en lecture la fenêtre est avancée d'un élément au moyen de la procédure prédéfinie get(cf. 10.3.4) alors que pour un fichier ouvert en écriture l'élément est véritablement écrit et la fenêtre avancée par la procédure prédéfinie put(cf. 10.3.4).
Exemples:
Soit la variable livre de type t_livre_cote(cf. 10.3.1). Alors
- si le fichier bibliotheque est ouvert en lecture:
livre := bibliotheque^; (* copier la valeur de l'élément courant dans livre *) get ( bibliotheque ); (* positionner la fenêtre sur l'élément suivant *)
- si le fichier bibliotheque est ouvert en écriture:
bibliotheque^ := livre; (* copier la valeur de livre dans la fenêtre *) put ( bibliotheque ); (* écrire la valeur contenue dans la fenêtre et *) (* avancer celle-ci *)
[ Retour à la table des matières ]
10.3.4 Procédures et fonctions prédéfinies
Soit la variable exemple d'un type fichier quelconque. Les procédures applicables à exemple sont les suivantes:
rewrite ( exemple ); ouvre le fichier exemple en écriture et l'initialise à la valeur "fichier vide" (le fichier ne contient que la marque de fin de fichier).La fonction eof ( exemple ) est alors vraie.
reset ( exemple ); ouvre le fichier exemple en lecture et positionne la fenêtre exemple^ sur le premier élément. Si le fichier est vide la fonction eof ( exemple ) est vraie.
put ( exemple ); écrit l'élément contenu dans exemple^ à la fin du fichier. Il faut s'imaginer que la marque de fin est alors placée après cet élément et que exemple^ est positionnée sur cette marque.
get ( exemple ); positionne exemple^ sur l'élément suivant du fichier. La fonction eof ( exemple ) devient vraie si cet élément est la marque de fin de fichier.
La fonction applicable à exemple est la suivante:
eof ( exemple ) donne la valeur true si la fenêtre exemple^ désigne la marque de fin de fichier, false sinon.
De nombreux dialectes offrent également la procédure
close ( exemple ); ferme le fichier exemple .
[ Retour à la table des matières ]
