Chapitre 6: Les enregistrements (Structures)

I / Introduction :

La variable de type tableau ne peut contenir que des éléments de même type. Lorsque l’on a
des données de types différents avec des liens logiques entre eux, on peut les regrouper dans
un même ensemble appelé enregistrement ou structure.
Exemple :
Décrire le groupe des informations que l’on pourrait lire sur une fiche d’un ouvrage de la
bibliothèque :

FICHE

Code Auteur Titre Editeur Année

Une fiche est alors une collection de cinq données élémentaires qui seront appelées des
champs.

Ce type est donc utilisé pour une structure complexe que nous souhaitons désigner par un seul
nom.

II/ Définition :
Un enregistrement est une structure de données composée d’un nombre fixe d’éléments qui
peuvent être différents. Les éléments d’un enregistrement sont appelés champs de
l’enregistrement et ils peuvent être de type simple ou composé.

III/ Déclaration :

a) déclaration d’une variable :/* on déclare une variable*/

Var <identificateur variable> : enregistrement

<identificateur champ1> : <type champ1> ;
<identificateur champ2> : <type champ2> ;
…
<identificateur champn> : <type champn> ;
Fin enregistrement ;

Remarque :
Le champ d’un enregistrement peut être à son tour de type composé. C'est-à-dire un champ
peut être de type tableau ou enregistrement.

Exemple :
Var Date : enregistrement
annee : entier ; /* annee, mois, jour :entier ;*/
mois : entier ;
jour : entier ;
Fin enreg ;
b) déclaration du type enregistrement : /* on définit un type et dans var on déclare une
variable */

Type <identificateur enregistrement> = enregistrement

<identificateur champ1> : <type champ1> ;
<identificateur champ2> : <type champ2> ;
…
<identificateur champn> : <type champn> ;
Fin enregistrement ; /* fin enreg ;*/

Var <identificateur variable> : <identificateur enregistrement> ;

Exemple :

Type coordonnee = enregistrement

X : reel ;
Y :reel ;
Fin enregistrement ;

Var point1, point2 : coordonnée ;

Remarque :
Si l’on doit transmettre un paramètre de type enregistrement dans une action paramétrée, on
choisira de déclarer le type enregistrement au lieu de déclarer une variable enregistrement.
(Même problème que le type tableau).

IV/ L’accès aux champs de l’enregistrement :

Nous accédons à chaque champ en utilisant :

- le nom d’identificateur de la variable de l’enregistrement ( Id_Enreg);
- un point ;
- le nom d’identificateur du champ (Id_Champ).

<Id_Enreg> . <Id_Champ>
Exemples :
Date. Annee2006 ; Date.mois 02 ; Date.jour 25 ;

Ou encore : lire(point1.X) ; lire(point1.Y) ;

Et aussi : ecrire(Date.annee ,’/’, Date.mois ,’ /’, Date.jour) ;

V/ Les opérations entre deux enregistrements :

La seule opération permise est l’affectation.

Exemple :
Type Date = enregistrement
Annee, mois, jour : entier ;
 Fin enreg ;
Var D1, D2 :Date ;
On peut écrire : D1  D2 ;

En revanche, il n’est pas permit de tester l’égalité, l’inégalité, < > comme suit :

Si D1=D2 …
Si D1<> D2 … tests non permit
Si D1<D2…
Si D1>D2…

On ne peut faire les testes que champ par champ comme suit :

Si D1.annee>D2.annee Alors …

VI/ Les variables structurées mixtes :

a) Tableaux d’enregistrements :

Un étudiant : - est identifié par son nom, prénom et matricule ;

- lui est attribué une moyenne des examens.

Type
Etudiant = enregistrement
Nom, Prenom : chaîne ;
Matricule : entier ;
Moyenne : réel ;
Fin enregistrement ;

Dans une section on a 100 étudiants donc on déclare un tableau de 100 étudiants.

Var T : tableau[1..100] d’Etudiant ; /* tableau d’enregistrements */

Accès : T[i].nom …

b) Enregistrement de tableaux :

Nous pouvons construire une variable de type enregistrement dont tous ou certains
éléments sont des tableaux.
Le même exemple précédent mais un étudiant peut avoir plusieurs modules et plusieurs
moyennes de chaque module.
On a donc un tableau de 8 modules et un autre de 8 moyennes.

Type
Etudiant = enregistrement
Nom, Prenom : chaîne ;
Matricule : entier ;
Module : tableau[1..8] de chaîne ;
Moyenne : tableau[1..8] de réel ;
Fin enregistrement ;
Var T : tableau[1..100] d’Etudiant ;

Accès : T[i].Module[K] …
T
1 2 3
Nom prenom matricule

c) Enregistrement d’enregistrements :

L’un des champs d’un enregistrement peut aussi être un enregistrement.

Type
Date = enregistrement
annee, mois, jour : entier ;
Fin enregistrement ;
Etudiant = enregistrement
Nom, Prenom : chaîne ;
Matricule : entier ;
Date_naissance :Date ;
Moyenne : réel ;
Fin enregistrement ;

Var T : tableau[1..100] d’Etudiant ;

Accès : T[i].Date_naissance.annee …

Exercice 1 :

On veut représenter les coordonnées d’un point.

a- définir le type point,
b- définir un type pour représenter un tableau d’au plus 100 points,
c- écrire les actions paramétrées d’initialisation et d’affichage d’un point,
d- écrire les actions paramétrées de calcule du milieu de deux points et de la distance
entre deux points.
e- A l’aide des actions précédentes, écrire une fonction qui vérifie si quatre points donnés
a, b, c, d forment un parallélogramme (quatre points a,b,c,d forment un
parallélogramme si la distance entre le milieu de ac et le milieu de bd est inférieure à
epsilon donné).
f- Soit T un tableau de n points. Ecrire une action paramétrée qui construit un tableau Td
de toutes les distances entre ces points,
g- Ecrire une fonction qui retourne la distance minimale contenue dans Td.

Solution :

Type
a- Point=enregistrement
x,y :reel ;
 Fin enregistrement ;

Type
b- Tpoint=tableau[1..100] de point ;
TDist=tableau[1..4950] de reel ; /* somme d’une suite arithmétique

c- Procedure init(E-S/p :point);

Var

Debut
Ecrire(‘donner l’abscisse du point’) ;
Lire(p.x) ;
Ecrire(‘donner l’ordonnée du point’) ;
Lire(p.y) ;
Fin ;

Procedure affichage(E / p :point) ;

Var
Debut
Ecrire(l’abscisse du poit p =’,p.x, ’l’’ordonnée =’, p.y) ;
Fin ;

d- Procedure milieu(E/p1, p2 :point ; E_S/m:point);

Var

Debut
m.x(p1.x+p2.x)/2; m.y(p1.y+p2.y)/2 ;
Fin ;

Fonction distance (E/p1, p2 :point ): reel;

Var
d:reel;
Debut
d  Sqrt((p1.x-p2.x2)^2+(p1.y-p2.y)^2) ;
distance d ; /*ou retourne(d) ;*/
fin ;

e- Fonction parallel(a,b,c,d :point ; ep :reel) :booleen ;

var
m1,m2 :point ;
v :booleen ;

debut
milieu(a,c,m1) ;milieu(b,d,m2) ;
vfaux ;
si distance(m1,m2)<ep alors vvrai ;
fsi ;
 parallelv ; /*ou retourne(v) ;*/
fin ;

f- procedure tab_dist(E/ T:Tpoint, N:entier ; E_S/Td:TDist, K:entier);

var
i,j: entire;

Debut
K0;
pour i1à N-1 faire
pour ji+1 à N faire
kk+1 ;
Td[k]distance(T[i],T[j]) ;
Fait ;
Fait ;
Fin ;

Fonction Min(Td :TDist, k :entier) :reel ;

Var
M :reel ;

Debut
MTd[1] ;
Pour i2 à K faire
Si Td[i]<M alors MTd[i] ;fsi ;
Fait ;
MinM ;/*retourne(M) ;*/
Fin ;