Les enregistrements

Objectifs

À la fin de ce chapitre, l’élève doit être capable de :

• reconnaître les situations où les structures déjà connues ne suffisent plus ;
• définir un nouveau type groupant des données de natures différentes ;
• déclarer ce type et les objets qui en relèvent, en algorithmique et en Python ;
• accéder à une donnée élémentaire à l’intérieur d’une structure, même emboîtée ;
• construire et parcourir une collection de telles structures ;
• ranger cette collection selon l’une quelconque de ses données.

Plan du chapitre

1. Introduction
2. L’enregistrement
3. L’enregistrement imbriqué
4. Le tableau d’enregistrements
5. Les enregistrements en Python
6. Les erreurs les plus fréquentes
7. Retenons

Rappel de 3ème SI. Les parties 1, 2, 3.1, 3.2 et 4 reprennent le cours de 3ème. Nouveau en 4ème : la comparaison de deux dates (paragraphe 3.3) et les questions des applications qui l’utilisent.

1. Introduction

Activité 1

Un professeur veut traiter par programme les informations de sa classe. Pour chaque élève, il doit retenir un numéro, un nom, un groupe, une moyenne, et le fait que l’élève soit interne ou externe.

Avec les seules structures étudiées jusqu’ici, il déclare cinq tableaux :

Questions

1. Pourquoi le professeur ne peut-il pas ranger ces cinq informations dans un seul tableau ?
2. Le professeur veut classer ses élèves par moyenne croissante. Il trie le tableau Moyenne. Que devient son programme ?
3. Que faudrait-il pour que les cinq informations d’un même élève restent liées entre elles ?

Réponse

Un tableau ne contient que des éléments de même type. Or le numéro est un entier, le nom une chaîne de caractères, le groupe un caractère, la moyenne un réel et le statut un booléen : cinq types différents, donc cinq tableaux.

Si le professeur trie le seul tableau Moyenne, les quatre autres ne bougent pas. La moyenne de l’élève placé en première position n’est plus la sienne : elle se retrouve en face du nom d’un autre. Le programme continue de fonctionner et n’affiche aucune erreur, mais toutes les informations sont fausses.

Pour que les cinq informations restent liées, il faudrait qu’elles forment un seul élément, que l’on déplace d’un bloc. C’est ce que permet l’enregistrement.

2. L’enregistrement

2.1 Définition

Définition. Un enregistrement est un type de données défini par l’utilisateur, qui groupe un nombre fini de données appelées champs, de types éventuellement différents.

Chaque champ porte un nom et un type. Un champ a exactement les mêmes propriétés qu’une variable du même type : on peut l’affecter, le lire, l’afficher et l’utiliser dans un calcul.

L’enregistrement se distingue du tableau sur deux points : ses éléments peuvent être de types différents, et on les désigne par un nom, non par un indice.

2.2 Déclaration

Le type enregistrement n’existe pas d’avance : c’est l’utilisateur qui le crée. Deux formes de déclaration sont possibles.

Première forme : l’objet seul. Lorsqu’un seul objet est concerné et qu’aucun autre objet ne s’y réfère, l’enregistrement se déclare directement dans le tableau de déclaration des objets.

Syntaxe — tableau de déclaration des objets

Seconde forme : un nouveau type. Dès qu’il faut un tableau de tels enregistrements, ou qu’un module en reçoit un en paramètre, le type doit porter un nom : il se déclare alors dans le tableau de déclaration des nouveaux types.

Syntaxe

Exemple. Le type Eleve décrit un élève de la classe.

Remarque importante. Un type se déclare avant d’être utilisé : le tableau de déclaration des nouveaux types précède toujours le tableau de déclaration des objets.

2.3 Accès à un champ

Un champ se désigne par le nom de l’objet, un point, puis le nom du champ.

Syntaxe algorithmique

nom_objet.nom_champ

Cette écriture désigne une variable ordinaire, du type du champ. Elle s’emploie partout où une variable de ce type est permise.

E.Num ← 12
E.Nom ← "Yassine Trabelsi"
E.Groupe ← "A"
E.Moyenne ← 13.50
E.Interne ← Vrai

Remarque importante. Le point est obligatoire. Écrit seul, Num désigne une variable qui n’existe pas ; écrit seul, E désigne l’enregistrement entier.

2.4 Ce qui se fait champ par champ

Trois opérations ne s’appliquent jamais à un enregistrement entier : la lecture, l’affichage et la comparaison.

Lire et afficher

Chaque champ se lit et s’affiche séparément, comme une variable de son type.

Écrire("Numéro : ")
Lire(E.Num)
Écrire("Nom et prénom : ")
Lire(E.Nom)
Écrire("Moyenne : ")
Lire(E.Moyenne)
Écrire("Élève n° ", E.Num, " : ", E.Nom, ", moyenne ", E.Moyenne)

Lire(E) et Écrire(E) n’ont pas de sens : chaque champ a son type, donc son format de saisie et d’affichage.

Comparer

Deux enregistrements ne se comparent pas : E1 > E2, E1 < E2 et E1 = E2 n’ont pas de sens. Dire qu’un élève est « supérieur » à un autre ne signifie rien tant qu’on n’a pas dit sur quoi porte la comparaison.

On compare donc selon un champ, choisi en fonction de la question posée.

Si E1.Moyenne > E2.Moyenne Alors
    Écrire(E1.Nom, " a la meilleure moyenne")
Sinon
    Écrire(E2.Nom, " a la meilleure moyenne")
FinSi

Le champ choisi change la réponse. Sur la moyenne, Nour Bouzid, 16.25, l’emporte sur Yassine Trabelsi, 13.50 ; sur le numéro, 12 contre 7, c’est Yassine Trabelsi qui a le plus grand.

Il arrive qu’un seul champ ne suffise pas, parce que la réponse dépend de plusieurs champs à la fois. On les examine alors l’un après l’autre, du plus important au moins important. La comparaison de deux dates, au paragraphe 3.3, en est l’exemple type.

Remarque importante. On ne compare jamais deux enregistrements, on compare leurs champs : un seul lorsqu’il suffit à répondre, plusieurs, pris l’un après l’autre, lorsqu’il ne suffit pas.

2.5 Ce qui se fait d’un bloc : l’affectation

Deux enregistrements de même type s’affectent en une seule instruction. Tous les champs sont recopiés.

Syntaxe algorithmique

E1 ← E2

L’instruction E1 ← E2 équivaut à recopier les champs un à un :

E1.Num ← E2.Num
E1.Nom ← E2.Nom
E1.Groupe ← E2.Groupe
E1.Moyenne ← E2.Moyenne
E1.Interne ← E2.Interne

C’est cette possibilité qui rend l’échange de deux élèves possible dans un tri.

Remarque importante. Les deux enregistrements doivent être exactement du même type. Deux enregistrements qui auraient les mêmes champs sous deux noms de types différents ne s’affectent pas l’un à l’autre.

3. L’enregistrement imbriqué

3.1 Principe et déclaration

Un champ peut lui-même être un enregistrement. On parle alors d’enregistrement imbriqué.

Une date de naissance est composée de trois entiers : un jour, un mois et une année. Ces trois entiers n’ont de sens qu’ensemble. Les déclarer comme trois champs séparés de Eleve serait possible, mais on perdrait la possibilité de traiter la date comme un tout.

Remarque importante. Le type du champ se déclare avant le type qui l’utilise. Dans le tableau de déclaration des nouveaux types, Date précède donc Eleve.

TDNT

C’est la déclaration définitive du chapitre : toutes les parties suivantes l’utilisent.

3.2 Accès en cascade

On descend d’un niveau par point, autant de fois qu’il y a de niveaux.

E.Naissance.Jour ← 15
E.Naissance.Mois ← 3
E.Naissance.Annee ← 2009
Écrire("Né en ", E.Naissance.Annee)

E.Naissance est un enregistrement de type Date. Les règles du paragraphe 2.4 s’y appliquent : il s’affecte d’un bloc, E1.Naissance ← E2.Naissance, mais il ne se lit, ne s’affiche et ne se compare que champ par champ.

3.3 Comparer deux dates

Pour savoir lequel de deux élèves est le plus âgé, un seul champ de la date ne suffit pas. L’année ne départage pas deux élèves nés la même année ; le mois ne départage pas deux élèves nés le même mois de la même année. C’est le cas annoncé au paragraphe 2.4 : plusieurs champs décident, et on les examine l’un après l’autre, du plus significatif au moins significatif.

Les instructions suivantes rangent dans la variable booléenne avant la réponse à la question « E1 est-il né avant E2 ? ».

Si E1.Naissance.Annee ≠ E2.Naissance.Annee Alors
    avant ← E1.Naissance.Annee < E2.Naissance.Annee
Sinon
    Si E1.Naissance.Mois ≠ E2.Naissance.Mois Alors
        avant ← E1.Naissance.Mois < E2.Naissance.Mois
    Sinon
        avant ← E1.Naissance.Jour < E2.Naissance.Jour
    FinSi
FinSi

Le raisonnement est toujours le même : si le champ le plus significatif diffère, c’est lui qui décide ; sinon, on passe au suivant.

Autre écriture. La même réponse s’obtient en une seule condition, qui énumère les trois façons d’être né avant : une année plus petite, ou la même année et un mois plus petit, ou la même année, le même mois et un jour plus petit.

avant ← (E1.Naissance.Annee < E2.Naissance.Annee)
        Ou ((E1.Naissance.Annee = E2.Naissance.Annee)
            Et (E1.Naissance.Mois < E2.Naissance.Mois))
        Ou ((E1.Naissance.Annee = E2.Naissance.Annee)
            Et (E1.Naissance.Mois = E2.Naissance.Mois)
            Et (E1.Naissance.Jour < E2.Naissance.Jour))

Les deux écritures donnent toujours le même résultat. Dans la seconde, chaque comparaison est entre parenthèses : Et est prioritaire sur = et sur <.

Exemple.

Remarque importante. Comparer les trois champs séparément est faux. L’expression (D1.Annee < D2.Annee) Et (D1.Mois < D2.Mois) Et (D1.Jour < D2.Jour) rend Faux pour les dates 28/07/2008 et 15/03/2009, alors que la première est bien antérieure à la seconde.

4. Le tableau d’enregistrements

4.1 Principe et déclaration

Un tableau ne contient que des éléments de même type, et le type Eleve en est un : un tableau d’enregistrements est donc un tableau ordinaire, dont chaque case contient un enregistrement entier.

Chaque case contient les six champs d’un élève. Le champ Naissance, lui-même un enregistrement, est encadré à l’intérieur de la case.

Syntaxe — tableau de déclaration des nouveaux types

nom_type_tableau = Tableau de n nom_type_enregistrement

TDNT — à la suite de Date et de Eleve :

TDO

La taille déclarée est 35, l’effectif maximal d’une classe. La taille effective N est le nombre d’élèves réellement saisis : 1 ≤ N ≤ 35. Tous les traitements portent sur les indices 0 à N - 1.

4.2 Accès à un champ

On choisit d’abord quel élève, ensuite quelle information. L’indice vient donc avant le point.

Remarque importante. L’ordre ne s’inverse jamais. T.Moyenne[i] n’existe pas : T n’a pas de champ Moyenne, ce sont ses éléments qui en ont un.

Exemple de référence. Les six élèves qui suivent servent à vérifier tous les modules de ce chapitre. Ici N vaut 6.

Les valeurs de chaque case suivent l’ordre des champs du TDNT : Num, Nom, Groupe, Moyenne, Interne, puis les trois champs de Naissance.

4.3 Le remplissage

Deux écritures sont possibles, et toutes deux sont justes. La première confie la saisie d’un élève à un module séparé ; la seconde écrit cette saisie directement dans la boucle.

Première écriture : un module de saisie

Un module parcourt le tableau, un autre saisit un élève.

Procédure Remplir (@T : TabEleve, N : Entier)
DEBUT
    Pour i de 0 à N - 1 Faire
        Saisir_Eleve(T[i])
    Fin Pour
FIN

Procédure Saisir_Eleve (@E : Eleve)
DEBUT
    Répéter
        Écrire("Numéro : ")
        Lire(E.Num)
    Jusqu'à (E.Num ≥ 1) Et (E.Num ≤ 35)
    Écrire("Nom et prénom : ")
    Lire(E.Nom)
    Répéter
        Écrire("Groupe (A à D) : ")
        Lire(E.Groupe)
    Jusqu'à E.Groupe ∈ ["A".."D"]
    Répéter
        Écrire("Moyenne : ")
        Lire(E.Moyenne)
    Jusqu'à (E.Moyenne ≥ 0) Et (E.Moyenne ≤ 20)
    Écrire("Interne (Vrai / Faux) : ")
    Lire(E.Interne)
    Écrire("Jour de naissance : ")
    Lire(E.Naissance.Jour)
    Écrire("Mois de naissance : ")
    Lire(E.Naissance.Mois)
    Écrire("Année de naissance : ")
    Lire(E.Naissance.Annee)
FIN

N.B. On suppose la date de naissance saisie valide.

Remarque importante. Un champ imbriqué se saisit champ terminal par champ terminal, avec son chemin complet : Lire(E.Naissance.Jour), et non Lire(E.Naissance).

Seconde écriture : la saisie dans la boucle

La même saisie s’écrit aussi sans module séparé. Le corps de Saisir_Eleve devient le corps de la boucle, et E y est remplacé par T[i].

Procédure Remplir (@T : TabEleve, N : Entier)
DEBUT
    Pour i de 0 à N - 1 Faire
        Répéter
            Écrire("Numéro : ")
            Lire(T[i].Num)
        Jusqu'à (T[i].Num ≥ 1) Et (T[i].Num ≤ 35)
        Écrire("Nom et prénom : ")
        Lire(T[i].Nom)
        // les autres champs se saisissent de la même façon, sur T[i]
    Fin Pour
FIN

TDOL

Laquelle choisir

Remarque importante. Un module séparé n’est jamais obligatoire par principe. Il le devient lorsque le même traitement sert à deux endroits, ou lorsque l’énoncé le demande.

Application résolue 1 — La classe

On reprend la classe du paragraphe 4.2 : le tableau T contient les N élèves de la classe, déclarés avec les types Date, Eleve et TabEleve du chapitre.

Travail demandé

1. Écrire l’algorithme de la fonction Nb_Internes(T, N) qui retourne le nombre d’élèves internes.
2. Écrire l’algorithme de la fonction Nb_Groupe(T, N, g) qui retourne le nombre d’élèves du groupe g.
3. Écrire l’algorithme de la fonction Moyenne_Classe(T, N) qui retourne la moyenne de la classe.
4. Écrire l’algorithme de la fonction Position(T, N, x) qui retourne la position de l’élève de numéro x, et -1 si aucun élève ne porte ce numéro.
5. Écrire l’algorithme de la fonction Meilleur(T, N) qui retourne la position de l’élève qui a la meilleure moyenne.
6. Écrire l’algorithme de la fonction Plus_Age(T, N) qui retourne la position de l’élève le plus âgé.
7. Écrire l’algorithme de la procédure Trier_Moyenne(T, N) qui range les élèves par ordre croissant de leur moyenne.
8. Un élève propose de ranger la classe du plus âgé au plus jeune en triant sur la seule année de naissance. Écrire l’algorithme de ce tri, puis montrer sur l’exemple qu’il ne répond pas à la question.
9. Écrire l’algorithme de la procédure Trier_Age(T, N) qui range les élèves du plus âgé au plus jeune.

N.B. Le tableau T est supposé déjà rempli. Les numéros, les moyennes et les dates de naissance sont deux à deux distincts.

Fonction Nb_Internes (T : TabEleve, N : Entier) : Entier
DEBUT
    nb ← 0
    Pour i de 0 à N - 1 Faire
        Si T[i].Interne Alors
            nb ← nb + 1
        FinSi
    Fin Pour
    Retourner nb
FIN

Fonction Nb_Groupe (T : TabEleve, N : Entier, g : Caractère) : Entier
DEBUT
    nb ← 0
    Pour i de 0 à N - 1 Faire
        Si T[i].Groupe = g Alors
            nb ← nb + 1
        FinSi
    Fin Pour
    Retourner nb
FIN

Fonction Moyenne_Classe (T : TabEleve, N : Entier) : Réel
DEBUT
    s ← 0
    Pour i de 0 à N - 1 Faire
        s ← s + T[i].Moyenne
    Fin Pour
    Retourner s / N
FIN

Fonction Position (T : TabEleve, N, x : Entier) : Entier
DEBUT
    i ← 0
    Tant que (i < N) Et (T[i].Num ≠ x) Faire
        i ← i + 1
    Fin Tant que
    Si i < N Alors
        p ← i
    Sinon
        p ← -1
    FinSi
    Retourner p
FIN

Fonction Meilleur (T : TabEleve, N : Entier) : Entier
DEBUT
    p ← 0
    Pour i de 1 à N - 1 Faire
        Si T[i].Moyenne > T[p].Moyenne Alors
            p ← i
        FinSi
    Fin Pour
    Retourner p
FIN

Fonction Plus_Age (T : TabEleve, N : Entier) : Entier
DEBUT
    p ← 0
    Pour i de 1 à N - 1 Faire
        Si Avant(T[i].Naissance, T[p].Naissance) Alors
            p ← i
        FinSi
    Fin Pour
    Retourner p
FIN

Fonction Avant (D1, D2 : Date) : Booléen
DEBUT
    Si D1.Annee ≠ D2.Annee Alors
        test ← D1.Annee < D2.Annee
    Sinon
        Si D1.Mois ≠ D2.Mois Alors
            test ← D1.Mois < D2.Mois
        Sinon
            test ← D1.Jour < D2.Jour
        FinSi
    FinSi
    Retourner test
FIN

Procédure Trier_Moyenne (@T : TabEleve, N : Entier)
DEBUT
    NC ← N
    Répéter
        Permut ← Faux
        Pour i de 0 à NC - 2 Faire
            Si T[i].Moyenne > T[i + 1].Moyenne Alors
                Aux ← T[i]
                T[i] ← T[i + 1]
                T[i + 1] ← Aux
                Permut ← Vrai
            FinSi
        Fin Pour
        NC ← NC - 1
    Jusqu'à Non(Permut) Ou (NC = 1)
FIN

Procédure Trier_Annee (@T : TabEleve, N : Entier)
DEBUT
    NC ← N
    Répéter
        Permut ← Faux
        Pour i de 0 à NC - 2 Faire
            Si T[i].Naissance.Annee > T[i + 1].Naissance.Annee Alors
                Aux ← T[i]
                T[i] ← T[i + 1]
                T[i + 1] ← Aux
                Permut ← Vrai
            FinSi
        Fin Pour
        NC ← NC - 1
    Jusqu'à Non(Permut) Ou (NC = 1)
FIN

Procédure Trier_Age (@T : TabEleve, N : Entier)
DEBUT
    NC ← N
    Répéter
        Permut ← Faux
        Pour i de 0 à NC - 2 Faire
            Si Avant(T[i + 1].Naissance, T[i].Naissance) Alors
                Aux ← T[i]
                T[i] ← T[i + 1]
                T[i + 1] ← Aux
                Permut ← Vrai
            FinSi
        Fin Pour
        NC ← NC - 1
    Jusqu'à Non(Permut) Ou (NC = 1)
FIN

5. Les enregistrements en Python

5.1 Le dictionnaire

Python ne possède pas de type enregistrement. Trois représentations sont possibles, et une seule convient.

Un dictionnaire est un ensemble de couples clé : valeur. Les clés sont uniques : elles jouent exactement le rôle des noms de champs.

5.2 Déclaration et accès

Syntaxe Python

nom_enregistrement = dict(champ1 = type1(), champ2 = type2(), …)

E = dict(Num = int(), Nom = str(), Groupe = str(),
         Moyenne = float(), Interne = bool())

Un champ se désigne par la clé entre crochets, et non par un point.

Remarque importante. Python ne connaît pas le type caractère : un caractère est une chaîne d’un seul symbole. Le champ Groupe se déclare donc str(), comme le champ Nom.

Comme en algorithmique, un enregistrement ne s’affiche pas d’un seul coup : on affiche champ par champ, print(E['Nom'], E['Moyenne']).

5.3 L’imbrication

Un champ peut être un dictionnaire. Deux écritures sont possibles, et donnent le même résultat.

# le type enfant d'abord, comme dans le TDNT
D = dict(Jour = int(), Mois = int(), Annee = int())
E = dict(Num = int(), Nom = str(), Naissance = D)

# ou directement
E = dict(Num = int(), Nom = str(),
         Naissance = dict(Jour = int(), Mois = int(), Annee = int()))

L’accès se fait en cascade, un couple de crochets par niveau.

5.4 Le tableau de dictionnaires

Un tableau d’enregistrements se représente par un tableau numpy dont chaque case reçoit un dictionnaire. Comme en algorithmique, on déclare 35 cases, et l’on n’en remplit que N.

Remplir case par case

On donne à chaque case son propre dictionnaire, puis on remplit ses champs.

from numpy import array

T = array([dict()] * 35)
for i in range(N):
    T[i] = dict()
    T[i]['Num'] = int(input("Numéro : "))
    T[i]['Nom'] = input("Nom et prénom : ")
    T[i]['Groupe'] = input("Groupe (A à D) : ")
    while not (T[i]['Groupe'] in ["A", "B", "C", "D"]):
        T[i]['Groupe'] = input("Groupe (A à D) : ")

Remarque importante. La ligne T[i] = dict() placée dans la boucle est indispensable. Sans elle, les cases du tableau désignent toutes le même dictionnaire, et le tableau ne contient en réalité qu’un seul élève.

L’instruction array([dict()] * 35) ne crée qu’un seul dictionnaire, et place dans les 35 cases un accès à ce même dictionnaire. Modifier une case modifie donc toutes les autres :

T = array([dict()] * 3)
T[0]['Nom'] = "Yassine"
print(T[1]['Nom'], T[2]['Nom'])    # affiche : Yassine Yassine

Le nom n’a été rangé que dans T[0], et pourtant T[1] et T[2] le contiennent aussi. Avec la ligne T[i] = dict() dans la boucle, chaque case a son propre dictionnaire, et T[1] ne contient aucun champ 'Nom'.

Remplir un enregistrement, puis le ranger

On peut aussi remplir d’abord un dictionnaire E, puis le ranger dans la case. C’est la traduction de T[i] ← E.

T = array([dict()] * 35)
for i in range(N):
    E = dict(Num = int(), Nom = str())
    E['Num'] = int(input("Numéro : "))
    E['Nom'] = input("Nom et prénom : ")
    T[i] = E

Remarque importante. Cette écriture n’est juste que si E est créé dans la boucle, à chaque tour. Créé une seule fois avant la boucle, E serait le même dictionnaire dans toutes les cases : après la saisie de trois élèves, les trois cases contiendraient le dernier.

5.5 Les modules de l’application 1 en Python

def Moyenne_Classe(T, N):
    s = 0
    for i in range(N):
        s = s + T[i]['Moyenne']
    return s / N

def Position(T, N, x):
    i = 0
    while (i < N) and (T[i]['Num'] != x):
        i = i + 1
    if i < N:
        p = i
    else:
        p = -1
    return p

def Avant(D1, D2):
    if D1['Annee'] != D2['Annee']:
        test = D1['Annee'] < D2['Annee']
    else:
        if D1['Mois'] != D2['Mois']:
            test = D1['Mois'] < D2['Mois']
        else:
            test = D1['Jour'] < D2['Jour']
    return test

def Trier_Moyenne(T, N):
    NC = N
    Permut = True
    while Permut and (NC > 1):
        Permut = False
        for i in range(NC - 1):
            if T[i]['Moyenne'] > T[i + 1]['Moyenne']:
                Aux = T[i]
                T[i] = T[i + 1]
                T[i + 1] = Aux
                Permut = True
        NC = NC - 1

Application résolue 2 — Le terrain de foot

Le gardien d’un terrain de foot de quartier note les réservations de la saison 2027. Chaque réservation est décrite par :

• Numero : un entier, le numéro de la réservation ;
• Client : une chaîne de caractères, le nom de la personne ou du club ;
• Terrain : un caractère, "A" ou "B" ;
• Duree : un entier, la durée réservée en minutes ;
• Payee : un booléen, vrai si la réservation a été réglée ;
• Date_Res : la date de la réservation, composée d’un jour, d’un mois et d’une année.

Le terrain accepte au plus 300 réservations par saison.

Exemple — cinq réservations :

Travail demandé

1. Donner le tableau de déclaration des nouveaux types de cette application.
2. Écrire l’algorithme de la fonction Nb_Impayees(T, N) qui retourne le nombre de réservations non réglées.
3. Écrire l’algorithme de la fonction Duree_Terrain(T, N, t) qui retourne la durée totale réservée sur le terrain t, en minutes.
4. Écrire l’algorithme de la fonction Premiere(T, N) qui retourne la position de la réservation la plus ancienne.
5. Écrire l’algorithme de la procédure Trier_Date(T, N) qui range les réservations de la plus ancienne à la plus récente.

N.B. Le tableau T est supposé déjà rempli. Deux réservations n’ont jamais lieu le même jour.

Fonction Nb_Impayees (T : TabReservation, N : Entier) : Entier
DEBUT
    nb ← 0
    Pour i de 0 à N - 1 Faire
        Si Non(T[i].Payee) Alors
            nb ← nb + 1
        FinSi
    Fin Pour
    Retourner nb
FIN

Fonction Duree_Terrain (T : TabReservation, N : Entier, t : Caractère) : Entier
DEBUT
    s ← 0
    Pour i de 0 à N - 1 Faire
        Si T[i].Terrain = t Alors
            s ← s + T[i].Duree
        FinSi
    Fin Pour
    Retourner s
FIN

Fonction Premiere (T : TabReservation, N : Entier) : Entier
DEBUT
    p ← 0
    Pour i de 1 à N - 1 Faire
        Si Avant(T[i].Date_Res, T[p].Date_Res) Alors
            p ← i
        FinSi
    Fin Pour
    Retourner p
FIN

Fonction Avant (D1, D2 : Date) : Booléen
DEBUT
    Si D1.Annee ≠ D2.Annee Alors
        test ← D1.Annee < D2.Annee
    Sinon
        Si D1.Mois ≠ D2.Mois Alors
            test ← D1.Mois < D2.Mois
        Sinon
            test ← D1.Jour < D2.Jour
        FinSi
    FinSi
    Retourner test
FIN

Procédure Trier_Date (@T : TabReservation, N : Entier)
DEBUT
    NC ← N
    Répéter
        Permut ← Faux
        Pour i de 0 à NC - 2 Faire
            Si Avant(T[i + 1].Date_Res, T[i].Date_Res) Alors
                Aux ← T[i]
                T[i] ← T[i + 1]
                T[i + 1] ← Aux
                Permut ← Vrai
            FinSi
        Fin Pour
        NC ← NC - 1
    Jusqu'à Non(Permut) Ou (NC = 1)
FIN

6. Les erreurs les plus fréquentes

Les erreurs suivantes portent sur les notions du chapitre. Chacune est illustrée par une instruction du cours.

Remarque importante. Presque toutes ces erreurs ont la même origine : traiter l’enregistrement comme une valeur simple. Un enregistrement se déclare, s’affecte et se range en bloc ; tout le reste se fait champ par champ.

7. Retenons

Enregistrement. Un enregistrement est un type défini par l’utilisateur, qui groupe des champs de types éventuellement différents. Un champ se désigne par le nom de l’objet, un point, puis le nom du champ.

Déclaration. Le type se déclare dans le tableau de déclaration des nouveaux types dès qu’un tableau ou un module s’y réfère. Un type s’écrit toujours avant celui qui l’utilise.

Opérations. Un enregistrement s’affecte d’un bloc, entre deux enregistrements de même type. Il se lit, s’affiche et se compare champ par champ.

Comparaison. On compare selon un champ lorsqu’il suffit à répondre. Lorsque la réponse dépend de plusieurs champs, comme pour une date, on les examine l’un après l’autre, du plus significatif au moins significatif.

Imbrication. Un champ peut être un enregistrement. On y accède en cascade, un point par niveau.

Tableau d’enregistrements. L’indice vient avant le point : T[i].Champ. La taille déclarée est un maximum ; la taille effective N est le nombre d’éléments réellement présents.

Tri. On teste sur un champ, et l’on permute les enregistrements entiers : la variable auxiliaire est du type de l’enregistrement.

Python. L’enregistrement est représenté par un dictionnaire, et le champ par une clé entre crochets. Ranger ou affecter un dictionnaire ne le recopie pas : chaque case d’un tableau doit recevoir son propre dictionnaire.

Teste tes connaissances

Un quiz corrigé question par question, puis des flashcards pour mémoriser les notions du chapitre.