Les Enregistrements.
C
ontrairement aux tableaux qui sont des structures de données dont tous les éléments sont de
même type, les enregistrements sont des structures de données dont les éléments peuvent être
de type différent et qui se rapportent à la même entité sémantique (analogie avec Merise).
Les éléments qui composent un enregistrement sont appelés champs. Ainsi, un enregistrement est
un ensemble de champs de type différent constituant une entité.
23. Déclaration D'un Type Structuré
Avant de déclarer une variable enregistrement, il faut avoir au préalable définit son type, c'est à dire
le nom et le type des champs qui le compose. Le type d'un enregistrement est appelé type structuré.
(Les enregistrements sont parfois appelé structures, en analogie avec le langage C)
Jusqu'à présent, nous n'avons utilisé que des types primitifs (caractères, entiers, réels, chaînes) et des
tableaux de types primitifs. Mais il est possible de créer nos propres types puis de déclarer des
variables ou des tableaux d'éléments de ce type.
Pour ce faire, il faut déclarer un nouveau type, fondé (basé) sur d'autres types existants. La déclaration
des types structurés se fait dans une section spéciale des algorithmes appelée Type, qui précède la
section des variables (et succède à la section des constantes). Si l’algorithme comporte des sous-
programmes, les types et les constantes sont déclarées en dehors du programme.
Syntaxes :
Type nom_type =Enregistrement
nom_champ1: type_champ1 ;
…
nom_champN: type_champN ;
end ;
Exemple en Pascal :
Type pesonne =Record
nom: string ;
prénom :string ;
age: integer ;
end ;
34 | P a g e
Chapitre 6 : Les Enregistrements.
24. Déclaration D'un Enregistrement
Après avoir défini le type structuré, on peut déclarer une ou plusieurs variables de ce type exactement
de la même façon que l’on déclare des variables d’un type primitif. Les variables de type structuré
sont appelées enregistrements.
Type pesonne =Record
nom: string
age: integer ;
Fin ;
Var pers1, pers2 : personne ;
Ainsi, pers1 et pers2 sont deux enregistrements de type personne et chacune de ces variables contient
un nom, et l’âge.
Représentation :
Les enregistrements sont composés de plusieurs zones de données, correspondant aux champs
Dans un enregistrement chaque champ doit avoir un nom différent, mais pour des enregistrements
différents, on peut réutiliser les mêmes noms de champ avec un type différent ou identique.
Exemple :
Type enregistrement1 =Record Type enregistrement2 =Record
a: integer ; a: char;
b :real ; b, c: real;
c: char ; end ;
end ;
25. Manipulation D'un Enregistrement
La manipulation d'un enregistrement se fait au travers de ses champs. Comme pour les tableaux,
il n'est pas possible de manipuler un enregistrement globalement, sauf pour affecter un enregistrement
à un autre de même type (ou le passer en paramètre). Par exemple, pour afficher un enregistrement il
faut afficher tous ses champs un par un.
25.1. Accès Aux Champs D'un Enregistrement
Alors que les éléments d’un tableau sont accessibles à travers leur indice, les champs d’un
enregistrement sont accessibles à travers leur nom, grâce à l'opérateur '.'. Donc, la
manipulation des variables de type enregistrement se fait champ par champ, et l’accès à un champ
donné se fait comme suit : nom_enregistrement . nom_champ ; Par exemple, pour accéder à l'âge
de la variable pers2, on utilise l’expression : [Link]
Remarque :
La lecture d'une telle expression se fait de droit à gauche : l'âge de la personne 2.
Attention le nom d'un champ est TOUJOURS précédé du nom de l'enregistrement auquel
il appartient. On ne peut pas trouver un nom de champ tout seul, sans indication de
l'enregistrement.
M. OUNNACI 35
Chapitre 6 : Les Enregistrements.
Les c h a m p s d'un enregistrement, tout comme les éléments d'un tableau, sont des variables
à qui on peut faire subir les mêmes opérations (affectation, saisie, affichage…etc.).
Exemple 1:
Programme de saisie des données concernant les personnes pers1 et pers2, puis affichage de la
différence d'âge entre ces deux personnes.
Program Exemple1 ;
Type
personne = record
nom : chaîne ;
prénom : chaîne ;
age : entier ;
end ;
Var pers1, pers2 : personne ;
Begin
Writeln( 'Entrez le nom puis l’âge de la personne 1') ;
Read( [Link], [Link]) // il est impossible d'écrire Saisir pers1
Write( 'Entrez le nom puis l'âge de la personne 2') ;
Read( [Link], [Link])
writeln ( 'La différence d'âge entre ', [Link], ' et ', [Link], ' est de ') ;
if ( [Link] > [Link]) then
write ([Link] – [Link], ' ans ')
else write ([Link] – [Link], ' ans ');
End.
25.2. Un Enregistrement Comme Champ D'une Structure
Supposons que dans le type personne, nous ne voulions plus l'âge de la personne, mais sa date de
naissance. Une date est composée de trois variables (jour, mois, année) indissociables. Une date
correspond donc à une entité du monde réel qu'on doit représenter par un type enregistrement à 3
champs.
Si on déclare le type date au préalable (le type de l’enregistrement champ doit être déclaré avant le
type de l’enregistrement qui le contient), on peut l'utiliser dans la déclaration du type personne pour le
type de la date de naissance. Un type structuré peut être utilisé comme type pour des champs d'un
autre type structuré.bOn accède à un champ de sous enregistrement comme suit :
nom_enregistrement.nom_sous_enregistrement.nom_champ
Exemple :
TYPE
Date= record
jour: 1..31 ;
mois: 1..12 ;
annee: integer ;
end ;
personne=record
nom: string ;
ddn: date;
end;
var pers1 :personne;
M. OUNNACI 36
Chapitre 6 : Les Enregistrements.
Ainsi, pour accéder à l’année de naissance d’une personne il faut utiliser deux fois l'opérateur '.':
[Link] ;
25.3. Un Tableau Comme Champ De Structure
Il est possible aussi qu'un champ de type structuré soit de type tableau, voire tableau structuré !
Imaginons une structure mémorisant des critères géographiques de villes (altitude, climat, …). Certains
de ces critères pourraient pertinemment être mémorisés pour chaque mois de l'année (par exemple
température moyenne, précipitations moyennes, …).
Program exemple ;
Type Ville=record
Nom : string ;
Alt : integer ; //Altitude moyenne
Climat : string[30] ; //type de climat
Temp : array [1..12] of real ; //température moyenne par mois
End;
Var
MaVille : Ville;
i :integer ;
Begin
Write ('Nom de la ville ?') ;
Read ([Link]) ; //idem pour l'altitude et le climat
Write( 'Veuillez entrer successivement les températures moyennes sur les 12 mois') ;
for i := 1 to 12 do
Begin
Write ('mois ', i);
Read ([Link][i]);
End;
End.
Si on voulait afficher par exemple la température moyenne au mois de juillet de MaVille, on écrirait
tout simplement : Write ([Link][7]) ;
25.4. Les Enregistrements Comme Paramètres
Comme c'est le cas avec les tableaux, il est possible de passer un enregistrement en paramètre d'une
fonction ou d'une procédure (on n'est pas obligé de passer tous les champs uns à uns, ce qui permet de
diminuer le nombre de paramètres à passer). On peut aussi avoir un enregistrement comme valeur de
retour d'une fonction
Syntaxe
Type nom_type= record
End ;
Procedure ou function nom_procedure (nom_variable : nom_type);
M. OUNNACI 37
Chapitre 6 : Les Enregistrements.
Exemple :
Un programme qui contient une procédure qui reçoit en paramètre une variable de type enregistrement
puis l’affiche.
Program exemple ;
Type compte=record
Num_compte : integer ;
nom : string ;
solde real ;
End;
Var
c: compte;
i :integer ;
procedure proc (x: compte);
Begin
write( ' Affichage dans la procédure') ;
write (' N° compte :', X.num_compte) ;
write (' Nom :', [Link]) ;
write (' Solde :', [Link]) ;
End;
Begin
Write (saisir dans le programme principal ') ;
Write (' N° compte ?') ; Read (c.num_compte) ;
Write (' Nom ? ') ; Read ([Link]) ;
Write (' Solde ? ') ; Read ([Link]) ;
proc (c);
End.
26. Les Tableaux D'enregistrements (Tables)
Il arrive souvent que l’on veuille traiter non pas un seul enregistrement mais plusieurs. Par exemple, on
veut traiter un groupe de personne. On ne va donc pas créer autant de variables du type personne qu’il
y a de personnes. On va créer un tableau regroupant toutes les personnes du groupe. Il s’agit alors d’un
tableau d’enregistrements, autrement appelé « table ».
Syntaxe
Var nom_tableau : array [1..dimension] of type_enregistrement
Exemple :
Const
N = 20 // nombre de personnes du groupe
Type personne =record
nom: string ;
age: integer ;
end;
Var groupe: array [1..N] of personne;
Chaque élément du tableau est un enregistrement, contenant plusieurs variables de type
différent.
On accède à un enregistrement par son indice dans le tableau. Exemple : groupe[2] représente
la deuxième personne du groupe.
M. OUNNACI 38
Chapitre 6 : Les Enregistrements.
L’accès à un champ d’un enregistrement se fait comme suit :
nom_tableau[indice].nom_champ. Exemple : groupe[2].nom représente le nom de la
deuxième personne du groupe.
Représentation :
Attention : [Link][2] n’est pas valide group[2].nom
Exemple :
Program exemple ;
Const n=3 ;
Type compte=record
Num_compte : integer ;
Nom : string[30] ; //type de climat
End;
Var
Tab: array [1..n] of compte;
i :integer ;
Begin
For i :=1 to n do
Begin
Write ('le N° de compte & le nom du client ', i) ;
Read (Tab[i].num_compte, Tab[i].nom) ;
End;
Write( 'Voici le tableau d''enregistrement saisi') ;
for i := 1 to n do
Write ('N° compte = ', Tab[i].num_compte, ' Nom= ' , Tab[i].nom );
End.
26.1. Une Table Comme Champ De Structure
Les tableaux d'enregistrements peuvent aussi être eux même servir de type dans un autre type structuré.
Exemple
Contexte : Dans un comité d'entreprise, on veut pouvoir connaître les enfants des employés et leur date
de naissance. On suppose que le nombre d'enfant maxi d'un employé est de 10.
M. OUNNACI 39
Chapitre 6 : Les Enregistrements.
Program exemple ;
Type Enfant =record
Nom : string ;
Prénom : string ;
Journaiss : integer ;
Moisnaiss : integer ;
Anneenaiss :integer ;
End ;
Employé =record
Nom : string ;
Prénom string ;
Nbenf : integer ; //nombre d'enfants
Progéniture : array [1..10] of enfant ;
End.
Var
TabEmp : array [1..MAX] of employe;
Pour afficher par exemple les anniversaires de tous les enfants de l'employé d'indice i, il faudrait
parcourir le tableau de ses enfants (avec un autre indice que i).
If (TabEmp[i].NbEnf <> ) 0 then //on vérifie d'abord que l'employé a des enfants
For j := 1 to TabEmp[i].NbEnf do
Begin
Write( TabEmp[i].Progéniture[j].Prénom) ;
Write('anniversaire le ', TabEmp[i].Progéniture[j].journaiss,TabEmp[i].Progéniture[j].moisnaiss
End
Else write( 'l'employé ', TabEmp[i].Nom, ' n''a pas d'enfant') ;
27. Les Enregistrements Avec Variantes
Supposons que dans les enregistrements du type personne, définit dans le paragraphe précédent, nous
avons besoin d’ajouter des informations relatives au statut marital de l’employé en introduisant :
- Son statut : marié, veuf, divorcé et célibataire.
- Suivant son statut :
o S’il est marié ou veuf : la date de son dernier mariage,
o S’il est divorcé, la date de son dernier mariage, la date de son divorce...etc.
o S’il est célibataire : une indication spécifiant s’il a ou non un domicile indépendant.
Nous pourrions prévoir des champs supplémentaires correspondant à l’ensemble de toutes ces
informations quitte à ne remplir, pour chaque employé, que les champs correspondant à son statut. En
fait, les langages informatiques comme pascal nous autorise de tenir compte de la structure « variable »
de notre enregistrement. Si nous
supposons que le type date a été Program exemple ;
Type statut_marital =(marie, veuf, divorce, celibataire) ;
préalablement (auparavant) défini, personne =record
notre nouveau type d’enregistrement Nom : string ;
pourrait être défini comme suit : Prénom : string ;
age : integer ;
nbr_enfant : integer ;
Case statut : statut_marital of
marie, veuf : date_mariage :date ;
divorce :prem_divorce :boolean ; date_divorce :date ;
celibataire : domicil_ind :boolean;
End ;
M. OUNNACI 40
Chapitre 6 : Les Enregistrements.
La partie introduite par case précise que suivant la valeur d’un champ discriminateur (ou sélecteur)
nommé statut, de type statut_marital, l’enregistrement sera considéré comme se poursuivant par
l’une des structures décrites entre parenthèses, en regard de chaque valeur possible.
Le discriminateur fait partie de l’enregistrement. Si employé par exemple, une variable de type
personne, le champ discriminateur sera simplement noté : [Link].
Remarque :
En fait, les différentes variantes peuvent être considérées comme différentes descriptions d’une
même zone mémoire. Ainsi, dans notre exemple, par exemple prem_divorce et domicil_ind désigne
un même emplacement d’un octet. De même, date_mariage et prem_divorce, correspondent à la
même adresse, mais à des tailles différentes (le type date occupe plusieurs octets).
28. L’Instruction With-Do
Elle permet d’omettre le nom de l’enregistrement dans l’instruction.
Syntaxe
With nom_enregistreemnt Do
Instructions ;
Exemple
Program enregistrement, ;
Const n=3 ;
Type employe =record
Nom : string ;
Prenom :string ;
End;
Var c: array [1..N] of employe;
I: integer;
Begin
For I:=1 to N do
With employe do
Begin
Writeln('entrez le Nom et le Prénom de l’’employé ') ;
Read(nom, prenom) ;
Writeln (‘le nom = ‘, nom) ;
Writeln(‘ le prénom = ‘, prenom) ;
End;
End.
L’instruction With employe demande en fait au compilateur de préfixer par employe tous les
identificateurs qui correspondent à un nom de champs de l’enregistrement employe. Sa portée est
naturellement limitée aux instructions mentionnées (entre begin et end) à la suite du mot réservé Do.
Bien entendu, un identificateur ne correspondant pas à un nom de champ de l’enregistrement employe,
n’est pas affecté par cette instruction.
M. OUNNACI 41
