Cours d’algorithmique
Partie 5
Prof. Hanae Moussaoui
Prof. Hanae Moussaoui 1
5. Les structures
Prof. Hanae Moussaoui 2
- Une structure est une collection de champs (ou attributs), chacun ayant
un type spécifique. Elle permet de regrouper plusieurs types de données
sous une seule unité logique.
Cela est utile lorsqu'on veut représenter des objets complexes qui ont
plusieurs propriétés
- Un tableau ne peut stocker que des données du même type. En
revanche, une structure peut contenir des champs de types différents.
Prof. Hanae Moussaoui 3
Exemple : Étudiant
- Si vous voulez stocker les informations d'un étudiant (nom, âge,
moyenne), un tableau ne serait pas adapté car ces données ont des
types différents (chaîne, entier, réel).
- Une structure, en revanche, permet de regrouper ces données.
Syntaxe Générale
En pseudo-code, la définition d'une structure ressemble à ceci :
Type Structure Nom_Structure
nom_champ1 : type1
nom_champ2 : type2
...
nom_champn : typen
FinStruct
Prof. Hanae Moussaoui 4
Exemple Pratique :
Définir une structure : Étudiant
Supposons que vous souhaitez représenter un étudiant avec ses
propriétés : nom, âge, et moyenne.
Type Structure Étudiant
nom : chaîne
âge : entier
moyenne : réel
FinStruct
Prof. Hanae Moussaoui 5
Déclaration et utilisation
Une fois la structure définie, on peut déclarer une variable de ce type et
y accéder.
Déclaration d'une variable :
variable étudiant1 : Étudiant
Affectation des valeurs :
é[Link] "Fatima"
étudiant1.âge 20
é[Link] 15.5
Prof. Hanae Moussaoui 6
Accès aux valeurs :
Ecrire (é[Link]) // Affiche "Fatima"
Ecrire (é[Link]) // Affiche 15.5
Remplissage des champs par l'utilisateur :
Pour remplir les champs de cette structure, on utilise des instructions pour
demander les données à l'utilisateur et les assigner à chaque champ.
Ecrire ("Entrez le nom de l'étudiant : ")
lire (é[Link])
Ecrire ("Entrez l'âge de l'étudiant : ")
lire (étudiant1.âge)
Ecrire ("Entrez la moyenne de l'étudiant : ")
lire (é[Link])
Prof. Hanae Moussaoui 7
Afficher les données saisies :
Ecrire ("Voici les informations de l'étudiant :")
Ecrire ("Nom : ", é[Link])
Ecrire ("Âge : ", étudiant1.âge)
Ecrire ("Moyenne : ", é[Link])
Prof. Hanae Moussaoui 8
Exercice 1 :
- Déclare une structure appelée Point contenant deux champs :x : réel, y
: réel.
- Déclare une variable p1 de type Point et demande à l'utilisateur de
saisir les valeurs de x et y.
- Affiche les coordonnées sous la forme : (x, y).
Prof. Hanae Moussaoui 9
Algorithme Coordonee
Type Structure Point
x : réel
y : réel
FinStruct
Variable p1 : Point
Ecrire("Saisir la coordonnée x : ")
Lire(p1.x)
Ecrire("Saisir la coordonnée y : ")
Lire(p1.y)
Ecrire("Les coordonnées du point sont : (", p1.x, ", ", p1.y, ")")
Prof. Hanae Moussaoui 10
Utilisation Avancée
Structures dans un tableau :
On peut combiner les structures avec des tableaux pour gérer plusieurs
objets de même type.
Déclaration :
variable
tableau étudiants[3] : Étudiant
Prof. Hanae Moussaoui 11
Remplissage des données :
tableau étudiants[3] : Étudiant
pour i de allant de 0 à 2 faire
Ecrire ("Entrez le nom de l'étudiant ", i+1, ": ")
lire (étudiants[i].nom)
Ecrire ("Entrez l'âge de l'étudiant ", i+1, ": ")
lire (étudiants[i].âge)
Ecrire ("Entrez la moyenne de l'étudiant ", i+1, ": ")
lire (étudiants[i].moyenne)
finpour
Prof. Hanae Moussaoui 12
Affichage des données :
pour i de allant de 0 à 2 faire
Ecrire ("Étudiant ", i+1, ":")
Ecrire ("Nom : ", étudiants[i].nom)
Ecrire ("Âge : ", étudiants[i].âge)
Ecrire ("Moyenne : ", étudiants[i].moyenne)
finpour
Prof. Hanae Moussaoui 13
Syntaxe générale d’un programme de structure :
Algorithme StructDeclaration
Type Structure Etudiant
nom: chaine de caractères
prenom: chaine de caractères
age: Entiers
moyenne: Reels
FinStruct
Variables
etud1: Etudiant
etud2: Etudiant
constantes ....
Début
.......
Fin
Prof. Hanae Moussaoui 14
Représentation en mémoire :
Tableau Structure
Un tableau est une collection linéaire d'éléments de même Une structure, en revanche, peut contenir des éléments de
type. En mémoire, tous les éléments du tableau sont stockés types différents. Les éléments sont toujours stockés de
de manière consécutive, les uns après les autres, dans des manière contiguë, mais les tailles des champs peuvent varier
cases contiguës. en fonction des types. En plus, certaines structures peuvent
Supposons que vous ayez un tableau d'entiers avec 3 éléments être alignées pour des raisons de performance ou de
compatibilité.
tableau T[3] : entier
Prenons la structure Etudiant avec un nom (chaîne de
[ 0x01 ] [ 0x02 ] [ 0x03 ] caractères), un âge (entier) et une moyenne (reel) :
En mémoire, la disposition pourrait ressembler à ceci :
4 octets 4 octets 4 octets
[ "Alice" ] [ padding ] [ 0x14 ] [ 15.5 ]
Chaque élément du tableau occupe le même nombre d'octets,
et les adresses mémoire sont consécutives. Si le tableau
contient 3 entiers (par exemple de type entier), chaque entier 20 octets 4 octets 4 octets 8 octets
occupera 4 octets, donc les 3 éléments seront stockés à des
adresses contiguës.
Prof. Hanae Moussaoui 15
Déclaration d'une structure avec un Remplir un tableau dans une structure:
tableau :
Variable étudiant : Étudiant
Type Structure Étudiant // Remplir le nom
tableau nom[50] : caractere Pour i allant de 0 à 49 Faire
tableau notes[5] : réel Lire(é[Link][i])
âge : entier FinPour
FinStruct // Remplir les notes
Pour i allant de 0 à 4 Faire
Lire(é[Link][i])
FinPour
// Remplir l'âge
Lire(étudiant.âge)
Les éléments du tableau sont stockés en mémoire de manière contiguë, juste après les champs précédents.
Prof. Hanae Moussaoui 16
Exercice 2 :
- Déclare une structure appelée Étudiant contenant :
• nom : chaîne[30]
• âge : entier
• note : réel
- Déclare un tableau étudiants[5] pour stocker les informations de 5
étudiants.
- Remplis le tableau en demandant à l'utilisateur de saisir les données de
chaque étudiant.
- Affiche les informations de tous les étudiants dans un format lisible.
Prof. Hanae Moussaoui 17
Algorithme Etudiant Ecrire("Saisir la note de l'étudiant ", i + 1, " : ")
Lire(étudiants[i].note)
Type Structure Étudiant FinPour
nom: chaine[30]
âge : entier // Affichage des données des étudiants
note : réel Ecrire("Informations des étudiants :")
FinStruct Pour i allant de 0 à 4 Faire
Ecrire("Étudiant ", i + 1, " :")
Variable Ecrire("Nom : ", étudiants[i].nom)
tableau étudiants[5] : Étudiant Ecrire("Âge : ", étudiants[i].âge)
i : entier Ecrire("Note : ", étudiants[i].note)
Ecrire ("\n")
// Saisie des données des étudiants Ecrire("-------------------")
Pour i allant de 0 à 4 Faire FinPour
Ecrire("Saisir le nom de l'étudiant ", i + 1, " : ") Fin
Lire(étudiants[i].nom)
Ecrire("Saisir l'âge de l'étudiant ", i + 1, " : ")
Lire(étudiants[i].âge)
Prof. Hanae Moussaoui 18
Exercice 3 :
- Déclare une structure appelée Étudiant contenant :
• nom : chaîne[30]
• âge : entier
• Tableau notes[3] : réel
- Déclare un tableau étudiants[5] pour stocker les informations de 5
étudiants.
- Remplis le tableau en demandant à l'utilisateur de saisir :Le nom de
chaque étudiant.
- L'âge de chaque étudiant.
- Les 3 notes pour chaque étudiant.
- Affiche les informations de tous les étudiants, y compris leurs noms,
âges, et les 3 notes.
Prof. Hanae Moussaoui 19
Algorithme Etudiant FinPour
Type Structure Étudiant FinPour
nom: chaine[30]
âge : entier // Affichage des données des étudiants
tableau notes[3] : réel Ecrire("Informations des étudiants :")
FinStruct Pour i allant de 0 à 4 Faire
Ecrire("Étudiant ", i + 1, " :")
Variable Ecrire("Nom : ", étudiants[i].nom)
tableau étudiants[5] : Étudiant Ecrire("Âge : ", étudiants[i].âge)
i, j : entier
// Affichage des 3 notes pour cet étudiant
// Saisie des données des étudiants Ecrire("Notes : ")
Pour i allant de 0 à 4 Faire Pour j allant de 0 à 2 Faire
Ecrire("Saisir le nom de l'étudiant ", i + 1, " : ") Ecrire(étudiants[i].notes[j], " ")
Lire(étudiants[i].nom) FinPour
Ecrire("Saisir l'âge de l'étudiant ", i + 1, " : ") Ecrire("-------------------")
Lire(étudiants[i].âge) FinPour
Fin
// Saisie des 3 notes pour cet étudiant
Pour j allant de 0 à 2 Faire
Ecrire("Saisir la note ", j + 1, " de l'étudiant ", i + 1, " : ")
Lire(étudiants[i].notes[j])
Prof. Hanae Moussaoui 20
Remarque :
Déclaration Interprétation Usage
tableau nom[50] : Un tableau contenant Stocker plusieurs
chaîne 50 chaînes (50 noms chaînes distinctes.
différents).
nom : chaîne[50] Une seule chaîne qui Stocker un seul texte
peut contenir jusqu'à (un seul nom complet).
50 caractères.
tableau nom[50] : Un tableau contenant Stocker plusieurs
caractere 50 caractères caractères distincts
Prof. Hanae Moussaoui 21
Exercice 4:
- Définir une structure Élève contenant :
nom : chaîne[40]
tableau notes[3] : réel
- Déclarer un tableau de 2 élèves.
- Saisir les informations des élèves, y compris leurs 3 notes.
- Calculer et afficher la moyenne des notes pour chaque élève.
Prof. Hanae Moussaoui 22
Algorithme Eleve Ecrire("Saisir la note ", j + 1, " de ",
Type Structure Élève élèves[i].nom, " : ")
nom : chaîne[40] Lire(élèves[i].notes[j])
notes : réel[3] FinPour
FinStruct FinPour
Variable // Calcul et affichage des moyennes
tableau élèves[2] : Élève Pour i allant de 0 à 1 Faire
i, j : entier somme ← 0
somme, moyenne : réel Pour j allant de 0 à 2 Faire
somme ← somme + élèves[i].notes[j]
// Saisie des élèves FinPour
Pour i allant de 0 à 1 Faire moyenne ← somme / 3
Ecrire("Saisir le nom de l'élève ", i + 1, " : ") : ",Ecrire("La
moyenne)
moyenne de ", élèves[i].nom, " est
Lire(élèves[i].nom) FinPour
Pour j allant de 0 à 2 Faire
Prof. Hanae Moussaoui 23
