Les Enumérations et les

structures
Les énumérations (les ensembles)
• Le type ensemble est créé par définition du domaine des valeurs qu’elle
contient, c'est-à-dire de la liste des valeurs constantes que peuvent
prendre les variables de ce type.
• les variables de ce type prennent une valeur parmi un ensemble. par
exemple pour un feu de circulation, la couleur est : vert, orange ou rouge.
• En Algorithmique, on déclare un ensemble en tant que type comme
indiqué ci-dessous.
• Le type ensemble déclaré peut être utilisé par des variables qui peuvent
avoir une des valeurs citée par le type ensemble.
• EX:
type couleur= ensemble (bleu, vert, rouge, blanc);
var c1 : couleur;
C1  vert;
Les énumérations (les ensembles) en C
• En langage C, on déclare un ensemble en utilisant le mot clé enum.
• Syntaxe: enum nouveautype {liste de symboles/choix/valeurs} ;
• Exemple:
enum couleur {blanc, bleu, jaune, vert, noir};
• Ensuite, On déclare une variable de type couleur en spécifiant le nom de l’enum
suivi par le nom de la variable à déclarer (exemple : enum couleur c1;)
• De plus, on peut affecter des constantes numériques pour chaque
couleur comme suit:
• enum couleur {blanc, bleu=1, jaune=2, vert=3, noir};
Les énumérations (les ensembles)

• Les ensembles peuvent êtres utilisés pour itérer dans boucles

comme:
type couleur= ensemble (bleu, vert, rouge, blanc);
var c1:couleur;
pour c1= bleu jusqu’à blanc faire
écrire (c1);
Les structures (enregistrements)
• Contrairement 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 différents
types et qui se rapportent à la même entité sémantique. Les éléments
qui composent un enregistrement sont appelés champs ou attributs.
• Un enregistrement est un type de données défini par l'utilisateur et qui
permet de grouper un nombre fini d'éléments de types différents.
• Un enregistrement est une variable complexe qui permet de désigner
sous un seul nom un ensemble de valeurs pouvant être de types
différents (simples ou complexes).
Les structures (enregistrements)
• 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 composent.
• Il est possible de créer des types personnalisés, puis de déclarer des
variables ou des tableaux d’éléments de ce type.
Déclaration des enregistrements
• La déclaration des types structures 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.

• Où <id_ch1>, <id_ch2>, ..., <id_chN> sont les identificateurs des

champs et <type1>, <type2>, ..., <typeN> leurs types respectifs.
Déclaration des enregistrements
• Exemple :
Type voiture = enregistrement
Marque: chaine;
C: couleur; // le type couleur doit être déclaré au préalable
Prix: réel;
Fin;
Var v1,v2:voiture;
Accès au champs d’un enregistrement
• Les champs d'un enregistrement sont accessibles à travers leur nom,
grâce à l'opérateur '.’
• Pour accéder à un champ d'un enregistrement, on utilise L’identifiant
de la variable de type enregistrement suivi d’un point puis du nom du
champ auquel on veut accéder.
Syntaxe : <Variable_Enregistrement>.<Nom du champ>
• Par exemple, pour accéder au champ prix de la variable v1 de type
voiture, on écrit: v1.prix
• Affectation : v1.prix 2000,00;
Ou : varReel v1.prix;
• Lecture : lire (v1.prix);
Tableau (vecteur) d’enregistrement
• Afin de pouvoir gérer plusieurs entités d’un type donné (ex: voiture),
on utilise la structure tableau à une dimension pour stocker ces
éléments. Par exemple, on a besoin d’enregistrer 100 étudiants et
manipuler ses informations, on déclare la structure ‘étudiant’ et on
crée un vecteur de taille 100 d’éléments de type ‘étudiant’. Cela est
montré par l’exemple ci-dessous:
Type etudiant=enregistrement;
Nom:chaine;
…
Fin;
Var tableauEtudiant [100] : etudiant;
Opérations sur les structures
• Remplir (lire) les donner d’un nombre d’éléments de type structure:
Algorithme manipulerStructures
const n=10;
type voiture = enregistrement
marque: chaine;
c: chaine;
prix: réel;
fin;
var ListVoiture[n]:voiture;
i:entier;
debut
pour i 0 jusqu’à (n -1) faire
debut
lire(ListVoiture[i].marque);
lire(ListVoiture[i].c);
lire(ListVoiture[i]. prix);
fin;
fin.
Opérations sur les structures
• Afficher (écrire) les donner d’un nombre d’éléments de type structure:

pour i 0 jusqu’à (n -1) faire

debut
ecrire(ListVoiture[i].marque);
ecrire(ListVoiture[i].c);
ecrire(ListVoiture[i]. prix);
fin;
Opérations sur les structures
• Collecter des informations et des statistiques sur les données d’un
nombre d’éléments de type structure.
• Exemple : calcul de la moyenne des prix des voitures

moyennePrix0;
nbrVoiture0; // utilisé pour diviser la somme des prix sur le nbr de voiture (à voir
//l’utilisation de la constate n)
pour i 0 jusqu’à (n -1) faire
debut
moyennePrix moyennePrix+ ListVoiture[i]. prix;
nbrVoiture nbrVoiture + 1;
fin;
moyennePrix moyennePrix / nbrVoiture;
Opérations sur les structures
• Collecter des informations et des statistiques sur les données d’un
nombre d’éléments de type structure.
• Exemple : afficher la marque et la couleur de la voiture la plus chère

maxPrix ListVoiture[0]. prix;

indiceVoitureChere0; // cette variable est utilisé pour garder l’indice de la voiture la
//plus chère dans le tableau
pour i 1 jusqu’à (n -1) faire
debut
si (maxPrix <ListVoiture[i]. prix) alors;
debut
maxPrix   ListVoiture[i]. prix;
indiceVoitureCherei;
fin
fin;
ecrire("la voiture la plus chère est:"+ ListVoiture[indiceVoitureChere]. marque);
ecrire("la couleur de la voiture la plus chère est:"+ ListVoiture[indiceVoitureChere]. c);
Opérations sur les structures
• Collecter des informations et des statistiques sur les données d’un
nombre d’éléments de type structure.
• Exemple : tri décroissant des voitures selon leurs prix (utilisation de
l’algorithme de tri à bulle)
var tmp : voiture; j:entier;
…
pour i (n-2) jusqu’à 0 faire
debut
pour j 0 jusqu’à i faire
si(ListVoiture[j].prix> ListVoiture[j+1].prix)alors
debut
tmp ListVoiture[j]; // à voir la copie champ par champ en C
ListVoiture[j] ListVoiture[j+1];
ListVoiture[j+1]tmp;
fin;
fin;
Références
• Mguis, F. (s. d.). Algorithmique et Structures de Données II CH1 : Les
enregistrements. 2.
• https://telum.umc.edu.dz/pluginfile.php/139445/mod_resource/cont
ent/1/cours+enregistrements+en+algo+et+langage+C.pdf