ALGORITHME ET PROGRAMMATION 2

Support de cours
M. DEMBELE
(MASS II / 2005-2006)

PLAN
Chapitre I Les types structurés……...…………………………………………………….2
I-1 Définition………………………………………………………….……………………3
I-2 Les tableaux…………………………………………………………………………….3
I-3 Les ensembles…………………………………………………………………………..4

Chapitre II les algorithmes de tri………………………………………………………….6

II-1 Le problème du tri…………………………………………………………………….7
II-2 La spécification du tri…………...……………………………………………………7
II-3 Méthodes de tri………………………………………………………………………..7
II-3.1 Tri à bulles……………………………………………………………………...…7
II-3.2 Tri par sélection…………………………………………………………………..8
II-3.3 Tri par insertion…………………………………………………………………..9
II-3.4 Récursivité…….…………………………………………………………………10
II-3.4.1 Définition……………………………………………………………………10
II-3.4.2 Programme itératif,programme récursif…….…………………………...11
II-3.4.3 Exemples…………………………………………………………………….11
II-3.4.4 Le tri rapide…………………………………………………………………12
II-3.4.5 Tri par fusion……………………………………………………………….13

Chapitre III Les enregistrements………………………………………………………...16

III-1 Définition…………………………………………………………………………...17
III-2 Déclaration d’un type enregistrement…………………………………………...17
III-3 Accès et écriture……………………………………………………………………18
III-4 Instruction WITH…………………………………………………………………..18
III-5 Enregistrement avec variantes……………………………………………………19
III-6 Tableaux d’enregistrements…..………………………………………………..…21

Chapitre IV Les fichiers séquentiels…………………………………………………….22

IV-1 Définitions…………………………………………………………………………23
IV-2 Organisation et accès……………………………………………………………..23
IV-3 Les fichiers séquentiels en Pascal………………………………………………..24
IV-4 Les fichiers de texte……………………………………………………………….29

1
I - LES TYPES STRUCTURES

2
I – 1 Définition

Tout d’abord il faut remarquer que les types de bases que l’on utilisait
jusqu’ici ne nous permettent pas de représenter aisément de nombreuses valeurs
simultanément (les notes d’une classe, les propriètés de plusieurs individus,…). Ceci
a conduit à l’élaboration de types structurés qui peuvent être vus comme des
structures de données complexes composées de types de base. Ils sont donc obtenus
en regroupant des éléments de même type sous un seul nom (tableau, ensembles,…).

Une fois le type structuré crée, on ne peut accéder à ses éléments qu’en
utilisant les opérations de bases qui correspondent à ce type. La représentation de la
structure est alors cachée.

I – 2 Les Tableaux

Les tableaux, considérés comme des types structurés, sont donc composés
d’éléments de même type. On peut avoir un tableau d’entiers, de caractères, de
tableaux, d’enregistrements,… Les éléments d’un tableau sont rangés de façon
contiguë.

• La déclaration spécifie un intervalle d’indices I (les indices sont toujours des

entiers) et un type de base T (entier, réel, caractère, tableau,…).

var Tab: array[1..9] of integer ;

I 1 2 3 4 5 6 7 8 9
Tab Tab[1] Tab[2] Tab[3] Tab[4] Tab[5] Tab[6] Tab[7] Tab[8] Tab[9]

• Sélecteur : Tab[i] (i ∈ I ={1,2,3,4,5,6,7,8,9}) permet de sélectionner un

élément du tableau. Les Tab[i] sont donc des éléments de type T (Integer dans
notre cas).

• Assignation : Tab[i]:= valeur. Permet d’affecter des valeurs aux éléments

au tableau.

Exemple
Pour i ß 1 à 9 faire Tab[i] := i ;

Cette instruction affecte les valeurs du tableau et donne :

I 1 2 3 4 5 6 7 8 9
Tab 1 2 3 4 5 6 7 8 9

3
• Type de composantes: toutes identiques (le type T). Un tableau ne peut pas
contenir des composantes de type différent.

Puisqu’un tableau peut être composé de tableaux, on peut obtenir des tableaux
multidimensionnels.

• Déclaration: il suffit tout simplement de déclarer un tableau de tableaux

type Matrices = array[1..5] of array[1..3] of Type ;
(ou) Matrices = array[1..9,1..5] of Type ;

• Sélecteur:
var m : Matrices;
m[i][j] ou m[i,j].

m[1,1] m[1,2] m[1,3]

m[2,1] m[2,2] m[2,3]
m[3,1] m[3,2] m[3,3]
m[4,1] m[4,2] m[4,3]
m[5,1] m[5,2] m[5,3]

Le nombre de dimension d’un tableau n’est, dans la plupart des langages, pas
limité!

I – 3 Les ensembles

Les ensembles se rapprochent beaucoup de la notion mathématique

d’ensembles: des collections non ordonnées d’objets. Ils sont construits à partir
des types de base énumérés et permettent d’indiquer, pour chacune des valeurs
du type de base, si cette valeur est présente ou absente de l’ensemble en question.

• Déclaration d’un type ensemble (spécifie le type de base):

e : set of TypeDeBase

Exemples:
var S, Voyelles, Consonnes : set of char;
S := [ ]; Voyelles := [ ‘a’, ‘e’, ‘i’, ‘o’, ‘u’, ‘y’ ]; Consonnes := [ ‘b’..‘d’, ‘f’..‘h’, ‘j’..‘n’,
‘p’..‘t’, ‘v’..‘x’, ‘z’ ];

• Les opérations sur les ensembles:

L’affectation (:=), la réunion (+), l’intersection (*), la différence (-), la
comparaison (=, <>), l’inclusion (<=) et le test d’appartenance d’une valeur de
type de base (in). L’expression a ∉ S sera notée: not (a in S)

4
Remarques :

• Il n’y a pas de sélecteur possible

• L’ordre dans lequel sont mentionnées les expressions n’a aucune

importance: [5, 7] et [7, 5] sont identiques.

• Si l’on mentionne un intervalle dont la valeur de début est plus grande

que la valeur de fin [5 .. 2] alors l’ensemble est vide.

• Des constantes de type ensemble:

const voyelles = [ ‘a’, ‘e’, ‘i’, ‘o’, ‘u’, ‘y’ ];
const p = 10;
const valeurs = [p, 2*p, 3*p];

5
II - LES ALGORITHMES DE TRI

6
II – 1 Le problème du tri

Le tri est une opération qui a pour but de classer des objets, des documents,
des articles, …, dans l'ordre croissant ou décroissant suivant une propriété (date de
publication, auteur, taille,…) ou un numéro d'ordre attachés à chacun de ces objets. Il
est nécessaire que cette propriété ou ce numéro appartiennent à un ensemble
ordonné au sens mathématique (par exemple ordre lexicographique ou numérique).
Cet ensemble ordonné est appelé critère de tri. On peut donc se représenter les
éléments à trier comme un ensemble d’enregistrements dont la structure est la
suivante :

Clé ti Informations Di

Avec ( i = 1, ..., n )

Le but d'une opération de tri est de réaliser une permutation des indices pour que les
clés vérifient la relation d’ordre.

Exemple :

Soit un ensemble d’étudiants avec leurs poids en kilos

55 Aminata Fall
72 Ibrahima Diouf
68 Khady Mdodj
.. …
.. …

Les informations correspondent aux étudiants et le critère de tri est le poids. Le but
du tri est d’effectuer une permutation pour ranger ces éléments suivant le poids.

II – 2 Spécification du tri

Le problème du tri est simplifié en ne considérant pas d'informations Di et en

prenant pour clés ti des nombres entiers. Nous allons donc traiter le problème
suivant: soit un ensemble de n nombres entiers, (soit donc un tableau de n entiers) on
veut réarranger ces nombres de façon à ce qu'ils apparaissent dans l'ordre croissant
ou décroissant. (On retiendra dans la suite l’ordre croissant)

II – 3 Méthodes de tri

II – 3 – 1 Tri à bulles

Méthode de tri dans laquelle des paires de valeurs adjacentes dans la liste à
trier sont comparées et échangées si elles ne sont pas dans le bon ordre. Ainsi, lors
des passages, les entrées de la liste (ou du tableau) remontent comme des bulles.

7
Exemple : soit le tableau suivant à trier:

13 4 2 1 9

La première itération qui nous permet de comparer les éléments et de les échanger
repousse le plus grand élément au bout du tableau.
La deuxième laisse le 9 à sa place

13 4 2 1 9
4 13 2 1 9
4 2 13 1 9
4 2 1 13 9
4 2 1 9 13
La 2ème itération
4 2 1 9 13
La 3ème itération
4 2 1 9 13
2 4 1 9 13
2 1 4 9 13

Ainsi de suite jusqu’à obtenir le tableau trié :

1 2 4 9 13

Algorithme :

tri_bulle(T)
DEBUT
Permutation ß vraie
Tant qu’on effectue des permutations
DEBUT
Permutation ß faux;
Pour i allant de 1 à n-1 faire si T[i+1]<T[i] alors
DEBUT
permuter(T[i+1],T[i]);
permutation = vraie;
FIN
FIN
FIN

II – 3 – 2 Tri par sélection

On choisit le plus petit élément, on le sépare de la liste et on fait de même pour

les éléments restants.

8
Exemple :
Le premier parcours du tableau révèle l’élément 1 comme le plus petit, il faut le
permuter avec l’élément 13. La deuxième itération retrouve le second plus petit
élément, c'est-à-dire 2, et le permute avec le deuxième élément du tableau 4.

13 4 2 1 9
1 4 2 13 9
A la 2ème itération
1 4 2 13 9
1 2 4 13 9

Ainsi de suite jusqu’à l’obtention du tableau trié.

Algorithme :

tri_selection(T)
DEBUT
Pour i allant de 1 à n-1 faire
DEBUT
k ß i;
pour j allant de i+1 à n faire si T[j]<T[k] alors k ßj;
permuter (T[i],T[k]) ;
FIN
FIN

II – 3 – 3 Tri par insertion

On suppose que les i-1 premiers éléments du tableau sont triés dans l’ordre
croissant. Il faut maintenant insérer le ième élément à la bonne place dans la liste déjà
ordonnée.

Exemple :

Au départ on ne considère que le premier élément, soit 13, et on suppose qu’il est trié
puisqu’il est seul. On passe à l’élément 4. Il faut le placer correctement.

13 4 2 1 9
4 13 2 1 9
A la 2ème itération
4 13 2 1 9
2 4 13 1 9
A la 3ème itération
2 4 13 1 9

A la troisième itération, il faut placer l’élément 1 à sa bonne place.

9
Algorithme :

tri_insertion (T)
DEBUT
Pour i allant de 2 à n
DEBUT
el ß T[i];
jßi-1;
TANT QUE j>0 et el<T[j]
DEBUT
T[j+1]ßT[j];
jßj-1;
FIN
T[j+1]ß el;
FIN
FIN

II – 3 – 4 Récursivité

II – 3 – 4 – 1 Définition

Avant de donner la définition d’une récursivité, nous allons d’abord voir

quelques exemples d’utilisation de ce concept :

Le premier qu’on a déjà utilisé est le tableau de tableaux. Cela suppose que les
tableaux qui constituent le premier peuvent aussi être constitués de tableaux et ainsi
de suite.

Définition par récurrence (en mathématiques, on parlera plutôt de récurrence)

d'un nombre entier naturel : 0 est un entier naturel, si n est un entier naturel, alors n
+ 1 est aussi un entier naturel

Définition du factoriel : 0 ! = 1, pour tout n appartenant à N, n ! = n (n-1) !

On dira donc, en termes informatiques, qu’un objet est récursif, s'il se contient lui-
même ou s'il est défini à partir de lui-même. L’objet que nous utiliserons ici est la
fonction, puisqu’elle permet d’implémenter une tache, et on ira qu’une fonction
récursive est une fonction qui s’appelle elle-même dans sa définition.

Attention !

à Une fonction peut s’appeler elle-même dans son déroulement.

à Il faut nécessairement une condition d’arrêt.

10
II – 3 – 4 – 2 Programme itératif et programme récursif

La récursivité simplifie la structure d'un programme. Quoiqu'un programme

risque d'être beaucoup plus performant si l'on en élimine les appels récursifs, la
plupart du temps, le gain en simplicité vaut bien une baisse relative des
performances d'exécution.

La récursivité nécessite l'emploi de techniques spéciales de compilation, à

savoir le concept de pile. Ces techniques sont généralement plus coûteuses en temps
d'exécution que celles fondées sur l'itération. Ainsi il arrive que l'on souhaite éliminer
la récursivité dans les parties d'un programme les plus fréquemment exécutées. A cet
effet il est intéressant de noter que l'on peut montrer qu’il est toujours possible de
transformer un sous-programme itératif en un sous-programme récursif; cependant,
la réciproque n'est pas vraie. On peut donc dire que la classe des problèmes récursifs
contient celle des problèmes itératifs.

II – 3 – 4 – 3 Exemples

Calcul du factoriel.

factoriel(n)

DEBUT

si (n=0) alors renvoyer 1; /la condition d’arrêt

sinon renvoyer (n*factoriel(n-1)); /l’appel récursif

FIN

Nombre de Fibonacci.

Fibo(0) = Fibo(1) =1

Fibo(n)=Fibo(n-1)+Fibo(n-2);

Fibo(n)

DEBUT

si (n<=1) renvoyer 1; /la condition d’arrêt

sinon renvoyer( fibo(n-1)+fibo(n-2)); /l’appel récursif

FIN

Exercice : Donner les versions itératives de ces deux fonctions

11
II – 3 – 4 – 4 Le tri rapide

On partage le tableau en deux sous tableaux par rapport à un élément e pris

comme pivot. Les éléments du premier tableau (celui de gauche) sont inférieurs à e
tandis que les autres (ceux de droite) lui sont supérieurs. Ensuite on applique
récursivement le même procédé au deux tableaux.

Exemple :

Soit le tableau suivant :

13 4 2 1 9

Il s’agit de prendre le premier élément 13 comme pivot pour séparer le tableau en

deux parties :
4 2 1 9 13
A la 2èmeitération
2 1 4 9 13

A la deuxième itération, le pivot est l’élément 4, il faut distribuer les éléments 2, 1, et

9 à sa gauche ou à sa droite. A l’itération qui suit, le pivot est 2, il faut juste placer
l’élément 1 à sa gauche.

Algorithme :

tri_rapide(T,deb,fin)

DEBUT

si deb<fin alors

DEBUT

k=pivot(T,deb,fin);

tri_rapide(T,deb,k-1);

tri_rapide(T,k+1,fin);

FIN

FIN

On voit bien que l’on sépare le tableau avec la fonction pivot (qui est donnée ci-
dessous) en deux. Ensuite on a qu’à appliquer le même processus aux deux tableaux
obtenus. C’est bien de la récursivité.

12
pivot(T,i,j)

DEBUT

l=i+1;

k=j;

tant que (l<=k)

DEBUT

tant que(T[i]<T[k]) k=k-1;

tant que(T[i]>=T[l]) l=l+1;

Si (l<k)

DEBUT

permuter(T[l],T[k]);

k=k-1;

l=l+1;

FIN

FIN

permuter(T[i],T[k]);

renvoyer (k);

FIN

II – 3 – 4 – 5 Le tri par fusion

On sépare le tableau en deux, on applique le tri récursivement sur chaque tableau et

on fusionne les deux tableaux.

Exemple :
13 4 2 1 9

La division du tableau en deux donne :

13 4 2 1 9

Il faut maintenant appliquer le même processus aux deux parties puis les fusionner.
On obtient :

13
 13 4 2 1 9

A gauche, on doit maintenant fusionner 13 et 4 qui sont deux tableaux triés et on

obtient le tableau [4, 13] trié. A droite on doit fusionner 2 et [1,9] et on obtient [1, 2, 9].
Il ne reste qu’à fusionner les tableaux [4, 13] et [1, 2, 9].

Algorithme

tri_fusion (T,deb,fin)

DEBUT

Si deb<fin

DEBUT

k ß (deb+fin)div2

tri_fusion (T,deb,k);

tri_fusion (T,k+1,fin);

fusion(T,deb,k,fin);

FIN

FIN

L’algorithme divise d’abord le tableau en deux parties puis applique récursivement

la méthode aux deux parties avant de les fusionner. Il ne reste plus qu’à définir une
fonction qui reçoit en entrée deux tableaux triés et qui les fusionne.

14
fusion(T,i,k,j)
DEBUT
sßi ; tßk+1 ; rßi ;
Tant que (s<=k) et (t<=j)
DEBUT
| SI (T[s]<T[t])
| DEBUT
| | Tab[r]ßT[s];
| | sßs+1 ;
| | rßr+1 ;
| FIN
| SINON
| DEBUT
| | Tab[r]ßT[t];
| | tßt+1 ;
| | rßr+1 ;
| FIN
FIN
SI (s>k)
POUR u allant de t à j
DEBUT
| Tab[r] ß T[u];
| rßr+1 ;
FIN
SINON
POUR u allant de s à k
DEBUT
| Tab[r] ß T[u];
| rßr+1 ;
FIN
Tß Tab ;
FIN

15
III - LES ENREGISTREMENTS

16
III – 1 Définition

La plupart des langages de programmation offrent plusieurs modes de

structuration parmi lesquels nous comptons les tableaux. Comme nous l'avons vu
plus haut, le concept de tableau permet de grouper de manière structurée un nombre
fini d'informations de même type auxquelles on peut accéder par un indice.

Or, souvent il est nécessaire d'organiser de façon hiérarchique un ensemble de

données de types différents, mais qualifiant un même objet, comme par exemple les
informations concernant une personne (nom, prénom, âge, date de naissance, etc.) ou
bien les données d'un véhicule (type de véhicule, numéro d'immatriculation, etc.).

Pour résoudre ce genre de problèmes, la majorité des systèmes de programmation

récents, mettent à la disposition de l'utilisateur une telle structure hiérarchique. En
Pascal, une telle structure hiérarchique existe et est connue sous les noms de type
structuré enregistrement (RECORD) ou bien tout simplement structure
d'enregistrements. Un enregistrement est un assemblage dans un ordre bien
déterminé de variables de différents types. Ces composantes sont appelées des
champs.

III – 2 Déclaration d’un type enregistrement

La déclaration d'une structure d'enregistrements est initialisée par le mot

réservé RECORD et se termine avec le mot réservé END. Chaque champ est
caractérisé par son identificateur et son type. Les identificateurs de plusieurs champs
de même type sont séparés par des virgules.

Exemple :

TYPE TSexe = ( Masc, Fem );

TMatricule = 1..5000;
TEtatCivil = (Celibataire, Marie, Divorce, Veuf );
TPersonne= RECORD
Nom, Prenom: String[20];
Sexe: TSexe;
Mat: TMatricule;
Age: 15..65;
Etat: TEtatCivil
END ;

Var personne1, personne2 : TPersonne ;

17
III – 3 Accès et écriture

Pour accéder à un champ d'un enregistrement et travailler avec (saisie,

affichage), il suffit de le noter de la manière suivante:

< Identificateur de l'enregistrement >.< identificateur du champ >

Suivant l’exemple donné ci-dessus, [Link] donne accès au champ Nom de

la variable personne1.

Affectation :
[Link] :=’Diop’ ; [Link] :=’Ibou’ ; [Link] :=Masc ;…
On peut également affecter un enregistrement à un autre : personne2 :=personne1 ;
On obtient alors les mêmes valeurs pour chaque champ.

Attention !!!
Il n'est pas possible de construire une valeur d'une variable de type enregistrement
en utilisant directement son identificateur dans une instruction Read ou Readln. Par
exemple, l'instruction Read(personne1); n'est pas permise. Par contre, il est tout à fait
légal de l'écrire de la manière suivante: Read([Link], [Link]).

III – 4 L’instruction With

Permet l'accès direct aux champs d'un enregistrement. Les identificateurs des
champs serviront dès lors d'identificateurs de variables

Exemple :
VAR P: TPersonne;
la séquence:
[Link] := 'Diop';
[Link] := 'Mamadou';
[Link] := Masc;
[Link] := 2500;
[Link] := 30;
[Link] := Marie;

peut s'écrire:

WITH P DO
BEGIN
Nom: = 'Diop' ;
Prenom := 'Mamadou';
Sexe := Masc;
Mat := 2500;
Age := 30;
Etat := Marie
END;

18
Vu qu’un champ peut aussi se présenter sous forme d’un autre enregistrement,
l’imbrication d’instructions with est possible.

III – 5 Enregistrement avec variantes

Certaines applications nécessitent des structures d'enregistrements permettant

de tenir compte d'une modification dans la description des composantes des
enregistrements en fonction de la valeur de certaines d'entre elles. Par exemple :
comment envisager la structure d'un enregistrement qui contient des informations
sur les enfants d'une personne en respectant que certaines personnes n'ont pas
d'enfants, que d'autres en ont un nombre élevé et qu'il est coûteux de prévoir un
espace mémoire maximal pour les personnes sans enfants ?

A l'intérieur de tels enregistrements, appelés enregistrements variables ou

encore enregistrements avec variantes, il est possible de préciser les variantes qu'un
enregistrement peut prendre, suivant un certain critère. Ainsi par exemple, la
structure d'un enregistrement peut varier en fonction de la valeur d'une ou de
plusieurs composantes particulières.

Exemple :

TYPE TEtatCivil = (Celibataire, Marie, Divorce, Veuf, Concubin);

TAge = 0..120;
TSexe = (Masc, Fem);
TDate = RECORD
Jour: 1..31;
Mois: 1..12;
Annee: 1900..2100
END;

TPersonne = RECORD
Nom, Prenom: String;
Age: TAge;
Sexe: TSexe;
CASE Etat: TEtatCivil OF
Celibataire: ( Seul: Boolean);
Marie: ( DateMariage: TDate; LieuMariage : String ;
Conjoint: RECORD
NomConjoint, PrenomConjoint: String
END;
NombreEnfants: 0..10 );
Divorce: ( DatePremierMariage, DateDivorce: TDate;
Nombre Enfants: 0..10 );
Veuf: ( DateMariage: TDate; NombreEnfants: 0..10 );
Concubin: ( )
END;

19
Pour toute personne, on aura comme partie fixe son nom, son prénom, son âge, son
sexe et son état civil. Pour une personne célibataire, on mentionnera le fait qu'il vive
seul ou non seul. Pour une personne mariée, on aura la date du mariage, le lieu du
mariage, le nom et le prénom du conjoint et le nombre d'enfants. Pour une personne
divorcée, on aura la date du premier mariage, la date du divorce et le nombre
d'enfants. Enfin, pour une personne veuve, on aura sa date de mariage et le nombre
de ses enfants.

La structure dépend alors de la valeur du champ Etat (qui, il ne faut pas

l’oublier, fait partie de la partie fixe). C’est le champ de sélection, qui doit avoir une
valeur scalaire (pas réel !). Suivant les valeurs données à ce champ, la structure va
prendre différentes formes.

Exemple :

VAR P: TPersonne;

Après l'affectation: [Link] := Marie;

la forme de la structure d'enregistrements correspondante s'écrira:

TYPE TPersonne = RECORD

Nom, Prenom: String;
Age: TAge;
Sexe: TSexe;
Etat: TEtatCivil;
DateMariage: TDate;
Lieu Mariage: String;
Conjoint: RECORD
NomConjoint, PrenomConjoint: String
END;
NombreEnfants: 0..10
END;

Cependant, si l'on modifie la valeur du champ Etat par l'affectation:

[Link] := Celibataire;

alors la forme correspondante de la structure d'enregistrements va devenir:

TYPE TPersonne = RECORD

Nom, Prenom: String;
Age: TAge;
Sexe: TSexe;
Etat: TEtatCivil;
Seul: Boolean
END;

20
Attention !!!

La partie fixe doit toujours précéder la partie variable et on ne peut avoir qu’une
seule partie variable.
Si pour un cas donné, la liste des champs éventuels est vide, il faut écrire () . C’est le
cas pour concubin.

III – 6 Tableau d’enregistrements

Un tableau comme annoncé précédemment peut avoir comme éléments des

enregistrements.

Exemple :

Var t : array [1..5] of TPersonne ;

Pour accéder au nom de l’élément i, il faudra tout simplement faire : t[i].Nom

21
IV - LES FICHIERS

22
IV – 1 Définition

Un fichier est une collection d'informations stockée sur un support physique :

disque, bande, CD-Rom...Lors de l'utilisation de fichiers, l'objectif est donc de
pouvoir conserver durablement l'information. Un fichier est donc une séquence de
données du même type enregistrées sur un support informatique (de manière
permanente).

Un fichier temporaire est un fichier conservé en mémoire centrale, lors de

l'exécution du programme. Il est détruit à la fermeture du fichier. Il a donc une durée
de vie limitée à l'exécution du programme. Un fichier permanent est un fichier
conservé en mémoire secondaire, en dehors de l'exécution du programme. Il existe
toujours à l'arrêt du programme, même si on éteint l'ordinateur. Le système
d'exploitation est responsable de la gestion de ces mémoires auxiliaires. Plus
précisément, la partie du système d'exploitation qui s'occupe des fichiers est le
système de fichiers. Le fichier est donc l'unité logique qui est stockée et gérée par le
système de fichiers. Ce dernier fournit les primitives de programmation pour :

à la création de fichier
à l’ouverture d'un fichier
à la lecture dans un fichier
à l’écriture dans un fichier
à la fermeture d'un fichier
à La destruction d'un fichier

IV – 2 Accès

On appelle mode ou méthode d’accès la façon selon laquelle on accède aux

enregistrements d’un fichier.

On parle d’accès séquentiel lorsqu’on accède à un enregistrement après avoir fait

défiler tous les enregistrements qui le précèdent. On parlera d’accès direct lorsque les
divers articles du fichier possèdent un numéro d’enregistrement et lorsqu’en fonction
de ce numéro on accède directement à l ‘enregistrement considéré. Cette méthode
d’accès implique que tous les éléments du fichier sont de même taille.

En Pascal tous les modes d’accès sont autorisés. On ne parlera donc pas de fichier
séquentiel ou de fichier à accès direct mais on parlera d’accès direct ou séquentiel à
un fichier. Le choix du mode d’accès dépend de plusieurs facteurs :

à le support du fichier : sur disque, tous les accès sont possibles ; sur bande seul
l’accès séquentiel est possible.

à le travail à effectuer : si l’on doit fréquemment rechercher, modifier ou supprimer

un seul article, le mode séquentiel est à éviter

23
à le temps de réponse : si le temps de réponse doit être faible, on évitera aussi l’accès
séquentiel.

IV - 3 Les fichiers séquentiels en Pascal

Un fichier Pascal est une séquence de données de même type et de longueur

indéfinie (dans la mesure du disponible au niveau du support). Ces données sont
stockées de manière permanente sur un support physique. La fin du fichier est
repérée par un marqueur de FIN_DE_FICHIER. On peut utiliser la fonction
booléenne EOF (end_of_file)

à EOF(fichier) = vrai si fin de fichier atteinte

à EOF(fichier) = faux sinon
La longueur du fichier est équivalente au nombre d'éléments du fichier.

IV – 3 – 1 Déclaration d'un fichier

Syntaxe : Type IDENTIFICATEUR = file of ID_TYPE_ELEMENTS;

Tous les types sont autorisés pour les éléments, sauf le type fichier !!!

Exemples :

type CODES = file of integer ;

TEXTE = file of char ;

ADRESSE = record
.....................
end;
REPERTOIRE = file of ADRESSE ;

COORDONNES = record
abscisse, ordonnee : real ;
end ;
TRACE = file of coordonnees ;

var LIVRE : TEXTE ;

FICHIER_CLIENT : REPERTOIRE ;
COURBE : TRACE ;

Autre possibilité :

var LIVRE : file of char ; FICHIER_CLIENT : file of ADRESSE ;

24
IV – 3 – 2 Création d’un fichier

Syntaxe : rewrite (ID_NOM_DE_FICHIER);

Cette instruction permet d'ouvrir un fichier 'en écriture', c'est-à-dire de créer le fichier,
et d'autoriser des opérations d'écriture dans ce dernier.

Différentes possibilités se présentent lors de l'appel de rewrite(F) : Le fichier F

n'existe pas : création d'un fichier F. Si le fichier F existe : effacement de toutes les
données inscrites dans l'ancien fichier F. EOF(F) devient vrai. Positionnement du
pointeur de fichier au début du fichier vide F. Le pointeur de fichier est un repère (un
marqueur) servant à indiquer l'adresse à laquelle il faudra lire ou écrire le prochain
enregistrement.

IV – 3 – 3 Association entre un nom interne et un nom externe

C'est une méthode, parfois nécessaire, qui varie selon le système informatique. Elle
n'est pas standard et diffère selon les compilateurs Pascal. Bien souvent, il est
nécessaire de différencier le nom interne du fichier, de son nom externe. Le nom
interne (ou nom logique) correspond au nom utilisé dans le programme. C'est donc
l'identificateur déclaré comme variable (ex : Var F : file of ...). Il s'agit donc du nom de
fichier vu par le programmeur et par le programme Pascal. Le nom externe (ou nom
physique) représente quant à lui le nom utilisé sur le disque, visible dans le
répertoire (dossier ou directory). Il s'agit donc du nom de fichier vu par l'utilisateur
et par le système d'exploitation.

Pour associer les deux noms en Turbo Pascal, on utilise la fonction assign :

Assign(ID_FICHIER_INTERNE, ID_FICHIER_EXTERNE);

Exemple :

assign(FICH,'a :[Link]') ;

Attention ! Il ne faut surtout pas oublier de refermer tous les fichiers ouverts grâce à
l'instruction close(fichier).

IV – 3 – 4 Ecriture dans un fichier

L'écriture dans un fichier est quasiment analogue à l'affichage d'une donnée à l'écran.
Il suffit simplement d'ajouter le nom logique du ficher.

25
 Syntaxe : write (F,x)

Ecriture de l'enregistrement x dans le fichier logique F.

Attention ! Le type de x doit être compatible avec le type déclaré par le fichier.

Etat du fichier :

à avant l'exécution de la commande :

à après l'exécution de la commande :

La commande écrit la valeur de x (ici la valeur 3) à l'endroit où pointe le fichier et

déplace ce pointeur d'une position vers la droite.

IV – 3 – 5 Ouverture d’un fichier existant

Dans un fichier séquentiel, pour pouvoir lire une donnée, il est impératif que le
fichier ait d'abord été ouvert 'en lecture'. Cela signifie qu'il n'est pas possible de lire
des informations dans un fichier ouvert avec Rewrite (ouverture 'en écriture'). Pour
la lecture, il ne faut donc pas initialiser le fichier avec l'instruction Rewrite, sinon
toutes les anciennes données du fichier seront perdues, le fichier sera écrasé lors de
cette réinitialisation. Il est alors nécessaire d'utiliser une autre instruction permettant
l'ouverture du fichier en mode lecture : l'instruction Reset.

Syntaxe : reset (ID_NOM_DE_FICHIER);

Le pointeur de fichier est positionné en face du premier enregistrement. Si le fichier

contient au moins un article, EOF(F) devient faux

IV – 3 – 6 Lecture dans un fichier

Comme pour l'écriture, la lecture dans un fichier est quasiment analogue à saisie
d'une donnée au clavier. Il suffit là encore d'ajouter le nom du ficher.

26
 Syntaxe : read (F,x)

Cette instruction permet de lire l'enregistrement du fichier repéré par le pointeur de

fichier (à l'adresse indiquée par ce dernier), puis de placer cet enregistrement dans la
variable x passée en paramètre. De même que pour l'instruction write, le type de x
doit être le même que celui spécifié lors de la déclaration du fichier. Cette instruction
ne peut être exécutée que si la commande reset(F) a été utilisée auparavant.

Etat du fichier :

à avant l'exécution de la commande :

à après l'exécution de la commande :

La commande lit la valeur pointée par le fichier et l'assigne à la variable précisée

dans son deuxième argument. x prend alors la valeur 5. Le pointeur est ensuite
déplacé d'une position vers la droite. Si la fin du fichier est atteinte, EOF(F) devient
vrai. Dans ce cas, si on essaie de lire le fichier, le programme génère une erreur. A
chaque exécution de l'instruction reset, EOF devient faux.

IV – 3 – 7 Fonctions de manipulation

close (F) : permet de fermer le fichier F et met à jour le fichier associé.

erase(F) : supprime le fichier externe, de la mémoire auxiliaire, associé à F.

rename(F,’nouveau_nom.dat’) : renomme le fichier externe. Ne marche que si le

fichier est fermé. Il faut aussi supprimer l’ancien support externe avec rename.

flush(F) : vide le buffer associé au fichier F. Au niveau physique, les transferts se font
à travers une mémoire tampon.

eof(F) : retourne vrai ou faux si on se trouve ou non en fin de fichier.

27
filepos(F) : retourne le numéro courant. Chaque enregistrement possède un numéro
d’enregistrement, le premier se voit attribuer le numéro 0. On a donc Rang=Numéro
d’enregistrement + 1.

filesize(F) : le nombre d’articles stockés dans le fichier.

seek(F,numéro) : permet d’accéder directement à l’élément dont le numéro

d’enregistrement est numéro. Pour accéder au kième enregistrement
(1<=k<=filesize(F)) dont le numéro est le k-1 on utilisera seek(F,k-1).

IV – 3 – 8 Exemples

Type Tpersonne = Record

Nom, Prenom : String;
End;
Var fic : file of Tpersonne;

Création :
...
Assign(fic,'[Link]');
Rewrite(fic);
Readln([Link]);
While [Link] <> 'zzz' Do
Begin
Readln([Link]);
Write(fic, personne);
Readln([Link])
End;
Close(fic) ;

Lecture:
...
Assign(fic,'[Link]);
Reset(fic);
While Not EOF(fic) Do
Begin
Read(fic, personne);
With personne Do Writeln(Nom, ' ', Prenom);
End;
Close(fic)
...

28
Modification :

...
Assign(fic,'[Link]);
Reset(fic);
If FileSize(fic) >= 3 Then
Begin
Seek(fic, 2);
Read(fic, personne);
Write([Link]);
With personne Do
Begin
Readln(Nom);
Readln(Prenom)
End;
Seek(fic, FilePos(fic)-1);
Write(fic, personne)
End;
Close(fic)
...

IV – 4 Les fichiers texte

Lorsqu'un fichier est défini sous forme text, on dit qu'il s'agit d'un fichier de texte.
Les formes d'écriture d'un fichier de texte ne diffèrent pas de celles des autres fichiers.
Le problème se pose, dans ce cas, de séparer le fichier en lignes. Il est donc nécessaire
de diposer d'un mécanisme pour indiquer le passage à la ligne. Pour cela, utiliser les
procédures Readln et Writeln.
La fonction booléenne Eoln (End of line) : Cette fonction est utilisable pour le
traitement des fichiers de texte. Elle retourne la valeur True, lorsqu'une fin de ligne
est atteinte, sinon False.

Var
F : Text;
rep : char;

Procedure ECRIT;
Var
c : char;
Begin
Rewrite(F, 'fichier textuel' );
Writeln( ' Tapez un texte et terminez par $' );
Repeat
read(c);
if c <> '$'
then

29
 if EOLN(F)
then
writeln(F,c)
else
write(F,c);
Until c='$';
Close(F);
End;

Procedure LIT;
Var
s : string;
Begin
Reset(F, 'fichier textuel' );
Writeln;
Repeat
readln(F,s);
writeln(s);
Until EOF(F);
Close(F);
End;

30