Algorithmique et Structures de Données 2 - TP N°4 : LES POINTEURS

Ce TP porte sur la manipulation des pointeurs en langage C, avec un accent sur l’allocation dynamique de mémoire, la gestion de tableaux via pointeurs, et l’utilisation de structures complexes. Il permet d’acquérir des compétences pratiques en gestion mémoire, en manipulation de tableaux dynamiques et en programmation structurée avec pointeurs. Pour suivre ce TP, il faut disposer d’un compilateur C et d’un environnement de développement permettant d’exécuter des programmes en C.

Objectifs

• Allouer et libérer dynamiquement de la mémoire avec malloc et free.
• Utiliser la syntaxe des pointeurs pour manipuler des tableaux.
• Écrire des fonctions pour saisir, afficher et analyser des tableaux d’entiers.
• Corriger et comprendre un programme C utilisant des tableaux dynamiques.
• Manipuler des structures contenant des pointeurs vers des chaînes de caractères.
• Développer des fonctions récursives pour traiter des structures complexes.

Prérequis et configuration

• Connaissances de base en langage C (variables, pointeurs, tableaux, structures).
• Compilateur C standard (gcc ou équivalent).
• Environnement permettant d’exécuter des programmes en C.
• Compréhension de la gestion dynamique de la mémoire (malloc, free).
• Notions sur la manipulation des chaînes de caractères via pointeurs.

Exercice 1 : Allocation dynamique et affichage de pointeurs

Dans cet exercice, vous devez créer un programme C qui déclare deux pointeurs sur des réels, réserve dynamiquement de la mémoire pour chacun, affecte des valeurs, affiche les adresses et les valeurs, puis libère la mémoire.

Étapes à suivre :

• Déclarez deux pointeurs p1 et p2 de type float *.
• Utilisez malloc pour réserver la mémoire nécessaire à un float pour chacun.
• Affectez la valeur -67.3 à l’emplacement pointé par p1 et 345.89 à celui pointé par p2.
• Affichez les adresses contenues dans p1 et p2 ainsi que les valeurs pointées.
• Libérez la mémoire allouée avec free.

Remarque : Dans la suite du TP, il est obligatoire d’utiliser la syntaxe des pointeurs pour manipuler les tableaux.

Exercice 2 : Fonctions de saisie, affichage et analyse d’un tableau d’entiers

Vous devez écrire plusieurs fonctions manipulant un tableau d’entiers via des pointeurs.

• SaisirTab(int *tab, int n) : cette fonction permet de saisir n entiers et de les stocker dans le tableau pointé par tab.
• PlusSouvent(int *tab, int n) : cette fonction détermine l’élément qui apparaît le plus souvent dans le tableau.
• AfficherTab(int *tab, int n) : cette fonction affiche les n entiers contenus dans le tableau.

Ensuite, écrivez un programme principal main() qui :

• Saisit un nombre m d’entiers dans un tableau dynamique T.
• Affiche le contenu du tableau.
• Affiche l’élément qui apparaît le plus souvent dans ce tableau.

Exercice 3 : Correction et analyse d’un programme avec tableau dynamique

Le programme donné crée un tableau dynamique d’entiers et initialise chaque case avec le double de son indice. Il contient plusieurs erreurs à corriger.

# include <stdio.h>
# include <stdlib.h>
main() {
   int T[N];
   int i;
   printf("Saisir la taille du tableau : ");
   scanf("%d", N);
   T = (int*) malloc(sizeof(int));
   for(i=1; i<N;i++)
      T[i] = i*2
}

Étapes :

• Corrigez les erreurs de déclaration et d’allocation mémoire.
• Assurez-vous que la taille N est correctement lue et utilisée.
• Allouez un tableau dynamique de taille N avec malloc.
• Initialisez chaque élément T[i] avec i*2, en commençant à i=0.

Supposons que l’utilisateur saisisse 8 comme taille, le tableau doit contenir :

0 2 4 6 8 10 12 14

Ensuite, avec les déclarations :

int *p, x;
p = T;

Évaluez les expressions suivantes :

• a) x = *T : valeur pointée par T (élément 0)
• b) p = p + 6 : déplacement du pointeur de 6 éléments
• c) *p = *p - 2 : décrémentation de la valeur pointée par p de 2
• d) p = p - 4 : déplacement du pointeur en arrière de 4 éléments
• e) *p = *p + *(T + 5) : addition de la valeur pointée par T+5 à la valeur pointée par p

Enfin, donnez le nouveau contenu du tableau T après ces opérations.

Exercice 4 : Structures et pointeurs dynamiques

Reprenez l’exercice sur les joueurs de rugby (TP9) en utilisant uniquement la syntaxe des pointeurs, sans utiliser la syntaxe des tableaux. Le tableau de structures contenant les 15 joueurs doit être alloué dynamiquement.

La structure JOUEUR est définie ainsi :

typedef struct {
  int num;
  char *nom;
  char *pren;
  float poids;
} JOUEUR;

Les champs nom et pren sont des pointeurs vers des chaînes de caractères allouées dynamiquement, supposées de taille 20.

Objectifs :

• Allouer dynamiquement un tableau de 15 joueurs.
• Allouer dynamiquement les chaînes de caractères pour nom et pren de chaque joueur.
• Utiliser uniquement la syntaxe des pointeurs pour accéder et modifier les données.

Exercice 5 : Gestion de structures imbriquées et fonctions récursives

On considère les structures suivantes :

typedef struct {
  int ncin;          // numéro CIN du participant
  char nom[20];      // nom du participant
  char prenom[20];   // prénom du participant
} PARTICIPANT;

typedef struct {
  int identifiant;       // identifiant de la compétition
  char nom_comp[10];     // nom de la compétition
  PARTICIPANT tab[20];   // tableau des participants
} COMPETITION;

Étapes à réaliser :

1. Développer la fonction saisir_participant() qui saisit toutes les informations d’un participant et retourne la structure correspondante.
2. Développer la fonction saisir_competitions(COMPETITION *C, int n) qui saisit les informations relatives à n compétitions en utilisant uniquement la syntaxe des pointeurs (pas de syntaxe tableau).
3. Développer la fonction récursive nbre_comp(COMPETITION *C, int n, int ncin) qui retourne le nombre de compétitions auxquelles un participant, identifié par son ncin, a participé.
4. Écrire un main qui :
• Saisit le nombre total n de compétitions (non négatif).
• Alloue dynamiquement un tableau Comp013 de n compétitions.
• Saisit les données des n compétitions.
• Saisit le ncin d’un participant et affiche le nombre de compétitions auxquelles il a participé.

Résultats attendus

• Exercice 1 : affichage correct des adresses des pointeurs et des valeurs -67.3 et 345.89.
• Exercice 2 : saisie correcte des entiers, affichage fidèle du tableau, et identification correcte de l’élément le plus fréquent.
• Exercice 3 : correction complète du programme, tableau dynamique initialisé avec les valeurs 0, 2, 4, 6, 8, 10, 12, 14 pour N=8, et mise à jour correcte du tableau après les opérations sur le pointeur p.
• Exercice 4 : allocation dynamique réussie du tableau de joueurs et des chaînes de caractères, manipulation uniquement par pointeurs.
• Exercice 5 : saisie complète des participants et compétitions, fonction récursive retournant le nombre correct de participations pour un ncin donné.

Pièges courants

• Oublier de libérer la mémoire allouée dynamiquement, ce qui peut provoquer des fuites mémoire.
• Confondre la syntaxe des pointeurs et celle des tableaux, notamment en manipulant les indices.
• Ne pas allouer assez de mémoire pour les chaînes de caractères dans les structures.
• Ne pas initialiser correctement la taille des tableaux dynamiques avant allocation.
• Dans l’exercice 3, oublier de déclarer N comme variable et de passer son adresse à scanf.
• Dans les fonctions récursives, ne pas prévoir le cas de base, ce qui peut entraîner une récursion infinie.
• Lors de la manipulation des pointeurs, faire des décalages incorrects qui pointent hors des limites du tableau.