Chapitre 7 tableaux et enregistrements algorithmique et stru

Télécharger PDF

Les Enregistrements en Algorithmique et en Langage C

Définition d'un Enregistrement

Contrairement aux tableaux, qui sont des structures de données dont tous les éléments sont de même type, les enregistrements (également appelés "structures" en langage C) sont des structures de données dont les éléments peuvent être de types différents. Ces éléments, qui composent un enregistrement, sont appelés champs.

Les Enregistrements en Algorithmique

Syntaxe d'un Enregistrement

En algorithmique, la définition d'un type enregistrement se fait généralement comme suit :

Type Tpersonne = enregistrement
    nom: chaine[20]
    prenom: chaine[20]
    age: entier
finenreg

Cette définition crée un nouveau type, Tpersonne, qui peut ensuite être utilisé pour déclarer des variables.

Déclaration d'une Variable de Type Enregistrement

Une fois le type d'enregistrement défini, on peut déclarer des variables de ce type. Par exemple :

Variable maPersonne: Tpersonne

Ici, maPersonne est une variable qui peut contenir un nom, un prénom et un âge.

Accès aux Champs d'un Enregistrement

Pour accéder ou modifier la valeur d'un champ spécifique d'un enregistrement, on utilise la notation point (.) :

maPersonne.nom <-- "Dupont"
maPersonne.age <-- 30
Afficher(maPersonne.prenom)

Imbrication d'Enregistrements

Un type enregistrement peut être utilisé comme type pour des champs d'un autre type enregistrement. Cela permet de créer des structures de données plus complexes et organisées.

Exemple d'Imbrication : Date de Naissance dans une Personne

Type StructureDate = enregistrement
    jour: entier
    mois: chaine[20]
    annee: entier
finStruct

Type StructurePersonne = enregistrement
    nom: chaine[20]
    ddn: StructureDate  // ddn est un champ de type StructureDate
finStruct

Exemple Plus Complexe : Fournisseur et Produit

Considérons le cas où un produit est livré par un seul fournisseur. Un fournisseur est caractérisé par son code, sa raison sociale, son adresse et son numéro de téléphone. Son adresse est elle-même une structure.

Type StructureAdresse = enregistrement
    num: entier
    rue: chaine[20]
    cp: chaine[20]
    ville: chaine[20]
finStruct

Type StructureFournisseur = enregistrement
    code_frs: chaine[20]
    raison_sociale: chaine[20]
    ad_frs: StructureAdresse // ad_frs est un champ de type StructureAdresse
    tel: chaine[20]
finStruct

Type StructureProduit = enregistrement
    code: chaine[20]
    lib: chaine[20]
    paht: reel
    pvht: reel
    txtva: reel
    frs: StructureFournisseur // frs est un champ de type StructureFournisseur
finStruct

Les Tableaux d'Enregistrements

Il est possible de déclarer un tableau dont chaque élément est un enregistrement. Cela permet de gérer une collection d'objets structurés de manière homogène.

Exemple : Tableau de Personnes

Type StructurePersonneSimple = enregistrement
    nom: chaine[20]
    age: entier
finStruct

Variable tabPersonnes: tableau [1..100] de StructurePersonneSimple

Pour accéder à un champ d'un élément du tableau, on combine l'indexation du tableau et l'accès au champ : tabPersonnes[i].nom.

Traduction en Langage C : Les Structures

Syntaxe et Déclaration des Structures en C

En langage C, les enregistrements sont appelés "structures" et sont définis à l'aide du mot-clé struct. Un livre, par exemple, peut être caractérisé par un titre, un code, un auteur, un éditeur et un prix.

struct ouvrage {
    char titre[20];
    int code;
    char auteur[30];
    char editeur[20];
    float prix;
};

Pour déclarer une variable de ce type, on utilise :

struct ouvrage monLivre;

Il est également courant d'utiliser typedef pour simplifier la déclaration des structures, permettant d'utiliser le nom de la structure sans le préfixe struct :

typedef struct {
    char titre[20];
    int code;
    char auteur[30];
    char editeur[20];
    float prix;
} Ouvrage; // Maintenant, on peut juste utiliser 'Ouvrage' au lieu de 'struct ouvrage'

Ouvrage monAutreLivre; // Déclaration simplifiée

Accès aux Champs d'une Structure en C

Pour accéder aux champs d'une variable de type structure, on utilise l'opérateur point (.), tout comme en algorithmique :

monLivre.code = 1234;
strcpy(monLivre.titre, "Le Seigneur des Anneaux"); // Utilisation de strcpy pour les chaînes
printf("Titre: %s\n", monLivre.titre);

Si la structure est accédée via un pointeur, on utilise l'opérateur flèche (->) :

Ouvrage *ptrLivre = &monLivre;
ptrLivre->code = 5678; // Équivalent à (*ptrLivre).code = 5678;

Les Tableaux de Structures en C

On peut déclarer un tableau dont chaque élément est une structure. Par exemple, un tableau de 10 ouvrages :

struct ouvrage bibliotheque[10];

Pour accéder à un champ d'un élément spécifique du tableau, on utilise :

bibliotheque[0].code = 1001;
strcpy(bibliotheque[1].titre, "Fondation");

Exercices Pratiques sur les Structures en C

Exercice 1 : Afficher un Livre

Écrire une fonction C qui permet d'afficher les informations d'une structure ouvrage.

void affich_livre(struct ouvrage l) {
    puts(l.titre);
    printf("Code: %d\n", l.code);
    puts(l.auteur);
    puts(l.editeur);
    printf("Prix: %.2f EUR\n", l.prix);
}

Exercice 2 : Saisir un Livre au Clavier

Écrire une fonction C qui permet de saisir les informations d'une structure ouvrage au clavier. Il existe deux approches principales :

1. **Retourner la structure par valeur :** La fonction crée et remplit une structure, puis la retourne.

struct ouvrage lecture1() {
    struct ouvrage l;
    printf("Saisir le titre: "); gets(l.titre);
    printf("Saisir le code: "); scanf("%d", &l.code); getchar(); // Consomme le '\n' résiduel
    printf("Saisir l'auteur: "); gets(l.auteur);
    printf("Saisir l'éditeur: "); gets(l.editeur);
    printf("Saisir le prix: "); scanf("%f", &l.prix); getchar(); // Consomme le '\n' résiduel
    return l;
}

2. **Passer la structure par adresse (pointeur) :** La fonction reçoit un pointeur vers une structure et modifie les champs directement.

void lecture2(struct ouvrage *l) {
    printf("Saisir le titre: "); gets(l->titre);
    printf("Saisir le code: "); scanf("%d", &l->code); getchar();
    printf("Saisir l'auteur: "); gets(l->auteur);
    printf("Saisir l'éditeur: "); gets(l->editeur);
    printf("Saisir le prix: "); scanf("%f", &l->prix); getchar();
}

Pour appeler ces fonctions et utiliser les résultats dans le programme principal (main) :

int main() {
    struct ouvrage l1, l2;

    printf("\n--- Saisie du livre 1 (par retour de valeur) ---\n");
    l1 = lecture1();        // Appel par retour de valeur
    printf("\n--- Saisie du livre 2 (par passage d'adresse) ---\n");
    lecture2(&l2);         // Appel par passage d'adresse

    printf("\n--- Affichage du livre 1 ---\n");
    affich_livre(l1);
    printf("\n--- Affichage du livre 2 ---\n");
    affich_livre(l2);

    return 0;
}

L'opérateur -> (flèche) est utilisé pour accéder aux champs d'une variable qui contient l'adresse d'une structure (un pointeur vers une structure).

Exercice 3 : Saisir un Tableau de Livres

Écrire une fonction C qui permet de saisir un tableau de structures ouvrage au clavier.

void lecture_tab(int *n, struct ouvrage livre[]) {
    int i;
    do {
        printf("Donner le nombre d'ouvrages (max 10) : ");
        scanf("%d", n);
        getchar(); // Consomme le '\n'
    } while ((*n <= 0) || (*n > 10));

    for (i = 0; i < *n; i++) {
        printf("\nSaisie de l'ouvrage %d:\n", i + 1);
        lecture2(&livre[i]); // Utilise la fonction lecture2 définie précédemment
    }
}

Exemple d'utilisation dans main :

int main() {
    struct ouvrage bibliotheque[10];
    int nbOuvrages;

    lecture_tab(&nbOuvrages, bibliotheque);

    printf("\n--- Affichage de tous les livres saisis ---\n");
    for (int i = 0; i < nbOuvrages; i++) {
        printf("\n--- Affichage du livre %d ---\n", i + 1);
        affich_livre(bibliotheque[i]);
    }
    return 0;
}

Exercice 4 : Saisie d'un Ouvrage avec Date Imbriquée

Définir une structure Ouvrage qui inclut une date d'édition, elle-même une structure imbriquée. Ensuite, écrire une fonction pour saisir un tel ouvrage.

typedef struct {
    int jour;
    char mois[12]; // Ex: "Janvier", "Février", etc.
    int annee;
} Date;

typedef struct {
    char titre[20];
    int code;
    char auteur[30];
    char editeur[20];
    float prix;
    Date date_edition; // Champ de type Date
} Ouvrage;

void lecture3(Ouvrage *l) {
    printf("Saisir le titre: "); gets(l->titre);
    printf("Saisir le code: "); scanf("%d", &l->code); getchar();
    printf("Saisir l'auteur: "); gets(l->auteur);
    printf("Saisir l'éditeur: "); gets(l->editeur);
    printf("Saisir le prix: "); scanf("%f", &l->prix); getchar();

    printf("--- Date d'édition ---\n");
    printf("Jour: "); scanf("%d", &l->date_edition.jour); getchar();
    printf("Mois: "); gets(l->date_edition.mois);
    printf("Annee: "); scanf("%d", &l->date_edition.annee); getchar();
}

Exercice 5 : Affichage d'un Ouvrage avec Date Imbriquée

Écrire une fonction C qui permet d'afficher les informations d'une structure Ouvrage avec une date d'édition imbriquée.

void Affich_livre2(Ouvrage l) {
    puts(l.titre);
    printf("Code: %d\n", l.code);
    puts(l.auteur);
    puts(l.editeur);
    printf("Prix: %.2f EUR\n", l.prix);
    printf("Date d'édition: %d %s %d\n", l.date_edition.jour, l.date_edition.mois, l.date_edition.annee);
}

Exercice 6 : Affichage d'un Ouvrage avec Tableau Imbriqué (Nombre de Sorties)

Modifier la structure Ouvrage pour y inclure un tableau indiquant le nombre de sorties du livre pour chaque jour du mois. Ensuite, écrire une fonction pour afficher cet ouvrage.

typedef struct {
    int jour;
    char mois[12];
    int annee;
} Date;

typedef struct {
    char titre[20];
    int code;
    char auteur[30];
    char editeur[20];
    float prix;
    Date date_edition;
    int nb_sorties[31]; // Tableau pour le nombre de sorties par jour du mois
} OuvrageAvecSorties;

void Affich_livre3(OuvrageAvecSorties l) {
    int i;
    puts(l.titre);
    printf("Code: %d\n", l.code);
    puts(l.auteur);
    puts(l.editeur);
    printf("Prix: %.2f EUR\n", l.prix);
    printf("Date d'édition: %d %s %d\n", l.date_edition.jour, l.date_edition.mois, l.date_edition.annee);

    printf("Nombre de sorties par jour du mois:\n");
    for (i = 0; i < 31; i++) {
        // Dans une application réelle, on s'assurerait que le jour 'i+1' est valide pour le mois en cours.
        printf("Jour %d: %d sorties\n", i + 1, l.nb_sorties[i]);
    }
}

Foire Aux Questions (FAQ)

Qu'est-ce qu'un enregistrement/une structure ?

Un enregistrement (ou une structure en C) est un type de données composite qui permet de regrouper des données de types différents sous un même nom. Chaque donnée individuelle au sein de l'enregistrement est appelée un champ.

Quelle est la différence entre un tableau et un enregistrement ?

Un tableau est une collection d'éléments de même type, accessibles par un indice numérique. Un enregistrement est une collection de champs de types potentiellement différents, accessibles par leur nom (nom de champ).

Quand doit-on utiliser un enregistrement ou une structure ?

On utilise un enregistrement ou une structure lorsqu'on souhaite modéliser une entité du monde réel (comme une personne, un livre, une date) qui possède plusieurs propriétés (champs) de types variés. Cela améliore l'organisation et la lisibilité du code en regroupant des données logiquement liées.