Année universitaire 2002-2003

Licence d'informatique Module 4 - partie "C / shell" Travaux pratiques 7 : 1. Exercice 1 : gestion d'une pile de coffrets. 2. Exercice 2 : version plus sophistiquée de l'exercice 1.

1. Exercice 1.

Une société de distribution de marchandises décide de commercialiser des "coffrets gourmands" avant les fêtes de Noël. Pour gérer son stock, elle ne dispose toutefois que d'un recoin dans un entrepôt où les coffrets gourmands devront être empilés les uns sur les autres. De plus, cet entrepôt ne permet pas de stocker plus de 200 coffrets gourmands à la fois. Cette société a besoin d'un logiciel de gestion de stock. C'est la création d'un tel logiciel qui est demandée dans cet exercice. On organisera son écriture en trois fichiers :

• Le fichier pile.c, déjà écrit lors de la séance 9 de travaux dirigés, contient les définitions d'un certain nombre de fonctions (génériques) permettant de manipuler une pile.

• Le fichier pile.h, déjà écrit lors de la séance 9 de travaux dirigés, est le fichier d'en-tête associé au fichier pile.c. Il contient également la définition du type cellule.

• Le fichier gestion.c, qui seul reste à écrire, devra essentiellement contenir la définition du type coffret et le programme principal main, qui appellera les différentes fonctions de gestion d'une pile définies dans pile.c.

On conseille de procéder de la façon suivante :

1) Dans le fichier gestion.c, on doit faire apparaître la directive d'inclusion du fichier pile.h (et non pas du fichier pile.c !), puisqu'on va utiliser le type cellule et les fonctions de manipulation de pile définis dans pile.c.

2) On doit également définir, dans le fichier gestion.c, la constante HAUTEUR_MAX à la valeur 200 et le type coffret (adapté aux besoins spécifiques de l'entreprise, contrairement au type générique cellule) :

typedef struct
{

int numero_arrivee;

char type;

} coffret;

Le premier champ de cette structure est un entier qui est le numéro d'arrivée du coffret dans le stock : le premier coffret stocké dans la pile recevra le numéro 1, le deuxième le numéro 2, etc..., si bien que le numéro d'un coffret sorti du stock ne pourra plus jamais être réattribué. Le deuxième champ de la structure coffret est un caractère, qui ne recevra pas de valeur dans le cadre de l'exercice 1, et qui permettra, dans le cadre de l'exercice 2, de stocker différents types de coffrets.

3) On doit aussi définir, dans le fichier gestion.c, la fonction creer_coffret, d'en-tête :

coffret *creer_coffret(void)

qui effectue l'allocation dynamique d'une zone mémoire correspondant à la taille d'une structure de type coffret, et qui retourne l'adresse de cette zone mémoire, ou NULL s'il y a un problème d'allocation de mémoire. Cette fonction sera appelée dans le programme principal, toutes les fois qu'on voudra empiler un coffret, avant d'appeler la fonction empiler (définie dans le fichier pile.c). L'adresse retournée par la fonction creer_coffret sera passée en paramètre à la fonction empiler.

4) Écrire le programme principal main, en respectant en particulier les points suivants :

• Déclarer et initialiser la variable p_pile comme suit :

cellule *p_pile=creer_pile();

Cette variable pointera sur le haut de la pile. Elle sera passée en paramètre à la plupart des fonctions, soit par valeur, soit par adresse (dans ce cas, le paramètre formel correspondant sera de type cellule **).

• Déclarer et initialiser la variable num_arrivee comme suit :

int num_arrivee=1;

La valeur de cette variable sera écrite dans le champ numero_arrivee du prochain coffret empilé dans le stock, et sera bien sûr incrémentée après chaque "tatouage".

• Faire afficher le menu suivant en boucle, tant que l'utilisateur ne tape pas 0 :

Vous pouvez :



1 - Commander une marchandise.

2 - Livrer une marchandise.

3 - Compter le stock.

0 - Sortir de l'application.

Votre choix :

• Commander une marchandise revient à empiler un nouveau coffret dans l'entrepôt, s'il reste assez de place.

• Livrer une marchandise consiste à dépiler un coffret, s'il en reste au moins un, et à afficher son numéro d'arrivée (ne pas oublier de faire ensuite un appel à la fonction free).

• Compter le stock consiste à produire un affichage indiquant le nombre de coffrets disponibles dans le stock.

• Sortir de l'application consiste à libérer tout l'espace mémoire alloué dynamiquement, et à terminer l'exécution du programme.

• On gérera la réponse de l'utilisateur, à l'intérieur de la boucle, par une instruction d'aiguillage à choix multiple (mot-clé switch, cf. la séance 4 de travaux pratiques).

5) Compiler le fichier gestion.c, à l'aide du fichier de description des dépendances de nom makefile (écrit lors de la séance 9 de travaux dirigés), de façon à produire le fichier exécutable de nom gestion

Attention :

Pour recopier le fichier makefile, ne pas procéder directement à l'aide de la souris, mais utiliser la commande suivante :

cp /users/linfg/linfg0/TD/td09ex02.txt makefile

6) Tester le programme exécutable obtenu. Dans un premier temps, il sera préférable de fixer la valeur de HAUTEUR_MAX à 3, pour pouvoir tester le cas où il ne reste plus de place dans l'entrepôt.

Remarques :

• À aucun moment, dans la résolution de cet exercice ou du prochain exercice, on ne devra utiliser les noms des champs de la structure cellule, c'est-à-dire qu'on ne doit utiliser ni p_info, ni p_suivant. Pour réellement empêcher que cela ne se produise, il faudrait enlever la définition du type cellule du fichier pile.h et définir un type légèrement différent dans le fichier pile.c. Cela rendrait l'exercice un peu trop complexe.

• On contrôlera que la gestion dynamique de la mémoire est correcte, à l'aide des deux variables globales cpt_malloc et cpt_free déjà introduites lors de la séance 4 de travaux pratiques. Une légère modification devra donc être apportée au fichier pile.c réalisé lors de la séance 9 de travaux dirigés.

2. Exercice 2.

La société décide maintenant de distribuer quatre types de coffrets :

• Le coffret "campagne" (foie gras-magret-armagnac), symbolisé par le caractère C

• Le coffret "mer" (caviar-saumon-langouste), symbolisé par le caractère M

• Le coffret "jeune" (hamburger-soda-milkshake), symbolisé par le caractère J

• Le coffret "lendemain" (café-aspirine-eau gazeuse), symbolisé par le caractère L

De plus, l'entrepôt s'est agrandi et peut désormais contenir 500 coffrets gourmants (on fixera d'abord la valeur de HAUTEUR_MAX à 5, pour pouvoir tester le cas où il ne reste plus de place dans l'entrepôt).

1) Faire une copie du fichier gestion.c, de nom gestion2.c

2) Définir, dans le fichier gestion2.c, les fonctions supplémentaires suivantes :

• creer_coffret_type, d'en-tête :

coffret *creer_coffret_type(char type)

Cette fonction effectue l'allocation dynamique d'une zone mémoire correspondant à la taille d'une structure de type coffret, affecte le caractère passé en paramètre au champ type de cette structure, et retourne l'adresse de cette zone mémoire, ou NULL s'il y a un problème d'allocation de mémoire.

• type_present, d'en-tête :

int type_present(char type,cellule *p_pile)

Cette fonction enlève les éléments situés au sommet de la pile, jusqu'à trouver un coffret du type passé en paramètre, auquel cas la valeur retournée est 1. Dans le cas où il n'y a pas de coffret du type recherché, la valeur 0 devra être retournée. Les coffrets qui sont dépilés seront empilés au fur et à mesure sur une pile temporaire. À la fin de la recherche, les éléments de la pile temporaire seront à nouveau empilés un à un sur la pile initiale. La valeur -1 sera retournée si un problème de saturation de la mémoire survient lors des transferts entre la pile principale et la pile temporaire.

• depiler_type, d'en-tête :

coffret *depiler_type(char type,cellule **pp_pile)

Cette fonction n'est appelée que si la fonction précédente a retourné 1. Elle enlève les éléments situés au sommet de la pile, jusqu'à trouver un coffret du type passé en paramètre, et retourne l'adresse de ce coffret, ou NULL si un problème de saturation de la mémoire survient lors du dépilage ou du rempilage (comme pour la fonction précédente, les coffrets qui sont dépilés seront empilés au fur et à mesure sur une pile temporaire). Lorsque le coffret cherché aura été trouvé et sorti de la pile, les éléments de la pile temporaire seront à nouveau empilés un à un sur la pile initiale.

• affichage_contenu_stock, d'en-tête :

int affichage_contenu_stock(cellule *p_pile)

Cette fonction affiche le nombre de coffrets de chaque catégorie disponibles dans le stock. Elle retourne 1 si tout s'est bien passé, et 0 si un problème de saturation de la mémoire survient lors du dépilage ou du rempilage (là encore, les coffrets qui sont dépilés seront empilés au fur et à mesure sur une pile temporaire).

• saisie_type, d'en-tête :

char saisie_type(void)

Cette fonction lit un caractère tapé au clavier par l'utilisateur, correspondant à l'un des quatre types de coffrets, et retourne ce caractère.

3) Modifier le programme principal de l'exercice 1, de façon à afficher le même menu en boucle, mais avec les modifications suivantes :

• Si un des quatre types de coffrets manque dans la pile, on commence par afficher (avant l'affichage du menu) les types de coffrets manquants, soit par exemple :

Il manque des coffrets de type "mer".
Il manque des coffrets de type "jeune".

• Commander une marchandise revient maintenant à demander à l'utilisateur le type du coffret qu'il souhaite empiler, puis à l'empiler dans l'entrepôt, s'il reste assez de place.

• Livrer une marchandise consiste maintenant à demander à l'utilisateur le type de cette marchandise, puis à extraire de la pile le premier coffret trouvé correspondant à ce type, s'il en reste au moins un, et enfin à afficher le numéro d'arrivée de ce coffret.

• Compter le stock consiste maintenant à afficher le nombre de coffrets de chaque catégorie disponibles dans le stock.

4) Compiler ce programme, et tester le programme exécutable produit.