TP N°3 : LES STRUCTURES

Ce document présente plusieurs exercices pratiques en langage C portant sur les structures de données. Il s'adresse principalement aux étudiants de première année en informatique ou en sciences appliquées, souhaitant maîtriser la définition, la manipulation et le traitement des structures en C à travers des cas concrets liés à la gestion d'équipes sportives, de compétitions, de dates, de stocks et d'albums musicaux.

Gestion d’une équipe de rugby avec des structures

On souhaite mémoriser les informations relatives aux 15 joueurs d’une équipe de rugby. Chaque joueur est caractérisé par :

• Numéro de poste (de 1 à 15)
• Nom
• Prénom
• Poids

Le numéro de poste détermine le rôle du joueur (par exemple, 1 = pilier gauche, 2 = talonneur, etc.).

Fonction de saisie des joueurs

Il faut écrire une fonction qui remplit un tableau de joueurs avec leurs informations, en contrôlant la validité du numéro de poste (entre 1 et 15) et du poids (valeurs positives). Après saisie, la fonction affiche toutes les informations des joueurs.

Fonction d’affichage du joueur le plus lourd et du poids moyen

Une autre fonction affiche :

• Le poids, le numéro de poste, le nom et le prénom du joueur le plus lourd
• Le poids moyen de l’ensemble des joueurs

Exemple minimal

typedef struct {
  int numero;
  char nom[30];
  char prenom[30];
  float poids;
} Joueur;

void saisirJoueurs(Joueur equipe[], int taille) {
  for (int i = 0; i < taille; i++) {
    do {
      printf("Numéro du joueur (1-15) : ");
      scanf("%d", &equipe[i].numero);
    } while (equipe[i].numero < 1 || equipe[i].numero > 15);
    printf("Nom : ");
    scanf("%s", equipe[i].nom);
    printf("Prénom : ");
    scanf("%s", equipe[i].prenom);
    do {
      printf("Poids (kg) : ");
      scanf("%f", &equipe[i].poids);
    } while (equipe[i].poids <= 0);
  }
  printf("\nJoueurs saisis :\n");
  for (int i = 0; i < taille; i++) {
    printf("%d - %s %s, poids : %.2f kg\n", equipe[i].numero, equipe[i].prenom, equipe[i].nom, equipe[i].poids);
  }
}

void afficherJoueurLePlusLourdEtMoyenne(Joueur equipe[], int taille) {
  int idxMax = 0;
  float somme = 0;
  for (int i = 0; i < taille; i++) {
    somme += equipe[i].poids;
    if (equipe[i].poids > equipe[idxMax].poids) {
      idxMax = i;
    }
  }
  printf("\nJoueur le plus lourd : %s %s, numéro %d, poids %.2f kg\n",
         equipe[idxMax].prenom, equipe[idxMax].nom, equipe[idxMax].numero, equipe[idxMax].poids);
  printf("Poids moyen de l'équipe : %.2f kg\n", somme / taille);
}

Gestion des participants et compétitions de tennis

La fédération de tennis souhaite gérer informatiquement les participants et les compétitions :

• Un participant est défini par un ncin, un nom et un prénom, chacun limité à 20 caractères.
• Une compétition est définie par un identifiant, un nom (max 10 caractères) et un ensemble de participants (max 50).

Définition des structures Participant et Competition

typedef struct {
  int ncin;
  char nom[21];
  char prenom[21];
} Participant;

typedef struct {
  int id;
  char nomCompet[11];
  Participant participants[50];
  int nbParticipants;
} Competition;

Fonction saisir_participant

Cette fonction permet de saisir et retourner un participant :

Participant saisir_participant() {
  Participant p;
  printf("NCIN : ");
  scanf("%d", &p.ncin);
  printf("Nom (max 20 caractères) : ");
  scanf("%20s", p.nom);
  printf("Prénom (max 20 caractères) : ");
  scanf("%20s", p.prenom);
  return p;
}

Fonction saisir_competitions

Cette fonction saisit les informations relatives à n compétitions :

void saisir_competitions(Competition S[], int n) {
  for (int i = 0; i < n; i++) {
    printf("Saisie compétition %d\n", i+1);
    printf("ID : ");
    scanf("%d", &S[i].id);
    printf("Nom compétition (max 10 caractères) : ");
    scanf("%10s", S[i].nomCompet);
    printf("Nombre de participants (max 50) : ");
    scanf("%d", &S[i].nbParticipants);
    if (S[i].nbParticipants > 50) S[i].nbParticipants = 50;
    for (int j = 0; j < S[i].nbParticipants; j++) {
      printf("Participant %d\n", j+1);
      S[i].participants[j] = saisir_participant();
    }
  }
}

Fonction nbre_comp

Retourne le nombre de compétitions auxquelles un participant donné (par son ncin) a participé :

int nbre_comp(Competition S[], int n, int ncin) {
  int compteur = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < S[i].nbParticipants; j++) {
      if (S[i].participants[j].ncin == ncin) {
        compteur++;
        break;
      }
    }
  }
  return compteur;
}

Programme principal (main)

Le programme principal permet :

• De saisir le nombre n de compétitions (non négatif)
• De définir un tableau S13 pour la saison 2013
• De saisir les données des n compétitions
• De saisir un ncin et d’afficher le nombre de compétitions auxquelles ce participant a pris part

Gestion des dates avec une structure DATE

La structure DATE contient :

• jour : chaîne de caractères de taille 3
• mois : chaîne de caractères de taille 3
• année : chaîne de caractères de taille 5

Fonction de saisie d’une date

Cette fonction saisit une variable d de type DATE en effectuant les contrôles nécessaires.

Fonction d’incrémentation d’une date

Cette fonction prend en paramètre une variable d de type DATE et un entier n (nombre positif de jours) et incrémente la date d de n jours.

Fonction d’affichage d’une date

Affiche le contenu d’une variable date.

Programme complet

Le programme saisit une date, l’incrémente, puis affiche la nouvelle date.

Gestion du stock d’un fournisseur de produits bureautiques

Le stock est un tableau d’articles, avec un maximum de 100 produits. Chaque article est défini par :

• Modèle (chaîne de caractères max 20)
• Prix unitaire
• Quantité disponible

Définition de la structure article

typedef struct {
  char modele[21];
  float prixUnitaire;
  int quantite;
} Article;

Fonction ajouterArticle

Cette fonction ajoute un nouvel article au tableau représentant le stock, à une position donnée :

void ajouterArticle(Article stock[], int *taille, Article a, int position) {
  if (position < 0 || position > *taille || *taille >= 100) return;
  for (int i = *taille; i > position; i--) {
    stock[i] = stock[i-1];
  }
  stock[position] = a;
  (*taille)++;
}

Structures commandeUnitaire et commande

Une commande d’achat passée par un client est définie par :

• Nom du client (chaîne de caractères)
• Tableau de commandes unitaires (max 100)

Une commande unitaire comporte :

• Modèle de l’article
• Quantité demandée

typedef struct {
  char modele[21];
  int quantiteDemandee;
} CommandeUnitaire;

typedef struct {
  char nomClient[50];
  CommandeUnitaire commandes[100];
  int nbCommandes;
} Commande;

Fonction de saisie des commandes unitaires

Cette fonction saisit un tableau vide de commandes unitaires, en demandant les modèles et quantités désirées.

Fonction retirerCommandeUnitaire

Cette fonction prend en paramètres le stock et une commande unitaire, recherche le modèle dans le stock et :

• Si la quantité disponible est suffisante, met à jour la quantité et retourne le prix total
• Sinon, informe l’utilisateur et retourne 0

Déroulement du programme

• Affichage du stock initial
• Constitution d’une commande de plusieurs produits
• Retrait de la commande et affichage du prix total

Gestion d’un album musical

On considère les types suivants :

typedef struct {
  int minutes;
  int secondes;
} Temps;

typedef struct {
  char Titre[30];
  char Interprete[30];
  Temps Duree;
} Chanson;

Définition du type Album

Un album est un ensemble de chansons, contenant au moins une chanson et au plus 12 :

typedef Chanson Album[12];

Fonction SaisirChanson

Permet de saisir toutes les informations d’une chanson :

void SaisirChanson(Chanson *C) {
  printf("Titre : ");
  scanf("%29s", C->Titre);
  printf("Interprète : ");
  scanf("%29s", C->Interprete);
  printf("Durée (minutes secondes) : ");
  scanf("%d %d", &C->Duree.minutes, &C->Duree.secondes);
}

Fonction AfficherChanson

Affiche toutes les informations d’une chanson :

void AfficherChanson(Chanson C) {
  printf("Titre : %s\n", C.Titre);
  printf("Interprète : %s\n", C.Interprete);
  printf("Durée : %d min %d sec\n", C.Duree.minutes, C.Duree.secondes);
}

Fonction ComparerDurees

Compare la durée de deux chansons :

• Retourne 1 si C1 est plus longue que C2
• Retourne 2 si C1 est plus courte que C2
• Retourne 0 si elles ont la même durée

int ComparerDurees(Chanson C1, Chanson C2) {
  int duree1 = C1.Duree.minutes * 60 + C1.Duree.secondes;
  int duree2 = C2.Duree.minutes * 60 + C2.Duree.secondes;
  if (duree1 > duree2) return 1;
  else if (duree1 < duree2) return 2;
  else return 0;
}

Fonction RemplirAlbum

Remplit un album A avec N chansons :

void RemplirAlbum(Album A, int N) {
  for (int i = 0; i < N; i++) {
    printf("Saisie chanson %d\n", i+1);
    SaisirChanson(&A[i]);
  }
}

Fonction récursive ChansonsMemeInterpret

Affiche toutes les chansons de l’album dont l’interprète est Intp et retourne le nombre de ces chansons :

int ChansonsMemeInterpret(Album A, int N, char Intp[]) {
  if (N == 0) return 0;
  int count = ChansonsMemeInterpret(A, N - 1, Intp);
  if (strcmp(A[N-1].Interprete, Intp) == 0) {
    AfficherChanson(A[N-1]);
    return count + 1;
  }
  return count;
}

Programme utilisateur

• Remplit un album avec N chansons
• Saisit le nom d’un interprète
• Affiche toutes les chansons de cet interprète et leur nombre
• Affiche la chanson la plus courte de l’album

Glossaire des termes clés

• Structure : Type de données défini par l’utilisateur regroupant plusieurs champs de différents types.
• Tableau de structures : Collection ordonnée d’éléments de type structure.
• Fonction de saisie : Fonction permettant de remplir une structure avec des données entrées par l’utilisateur.
• Commande unitaire : Élément d’une commande représentant un produit et la quantité demandée.
• Album : Ensemble de chansons, limité ici à 12 éléments.
• Recursion : Technique où une fonction s’appelle elle-même pour traiter un problème.
• Comparaison de durée : Opération permettant de déterminer l’ordre relatif de deux durées.

Points clés à retenir

• Les structures permettent de regrouper des données hétérogènes sous un même type.
• Le contrôle des saisies est essentiel pour garantir la validité des données.
• Les tableaux de structures facilitent la gestion d’ensembles d’objets similaires.
• Les fonctions peuvent manipuler des structures par valeur ou par adresse (pointeur).
• La récursion peut être utilisée pour parcourir et traiter des tableaux de structures.
• La gestion des stocks et commandes nécessite la mise à jour des quantités et la vérification des disponibilités.
• Les comparaisons entre structures (ex. durées) permettent d’implémenter des fonctions de tri ou de recherche.