T2.poo : Sujet du TP1
T2.poo : Sujet du TP1
Groupe ESIEE, Denis BUREAU, novembre 2001.
Attention !
Le sujet peut être modifié jusqu'à la veille du TD.
I. Les objectifs
- Prendre en mains l'environnement Visual C++.
- Programmer la gestion de stock du distributeur (toute cette
gestion sera évidemment reprise au TP suivant, mais en
l'adaptant à l'approche orientée objet).
II. Notions abordées dans les cours 0 et 1
- Les principaux concepts de l'approche Orientée Objet.
- Les atouts de cette approche.
- Les autres langages orientés objet.
- Les avantages du C++ par rapport au C.
- Des petits exercices pour mettre oeuvre quelques nouvelles
techniques de programmation C++ non orientées objet.
- La description de l'application "distributeur de boissons".
III. Références dans les polycopiés
Le polycopié "L'approche et les langages objet; introduction au C++"
et le corrigé du "TD1".
IV. Conseils généraux
Il s'agit de réaliser la gestion de stock du distributeur, avec, pour
l'instant, une approche non orientée objet, c'est-à-dire: un seul module,
des variables globales, de l'inclusion de code, etc...
Toutefois, le passage à l'objet lors du TP2 sera très simple.
Pour ce premier tp, l'unique produit considéré sera du type char.
On utilisera le type elem pour faciliter les modifications
ultérieures.
Dans les TP suivants, il faudra gérer des stocks de produits (boissons)
et ensuite également de pièces.
La gestion d'erreur est plutôt "sale", mais le système des exceptions
sera utilisé par la suite.
Le fichier STOCK.H contenant les déclarations est fourni dans le
répertoire
E:\TS2\PROF\BUREAUD\POO\TP1.
Le fichier TESTSTOC.INC contenant le programme de test (main) est également
fourni.
Recopiez ces deux fichiers sur un répertoire de C: .
Vous devez créer le fichier STOCK.CPP
qui implémente toutes les fonctions déclarées dans STOCK.H.
File/New, Files/C++ Source File, Location:, File Name:, OK.
Lisez le sujet jusqu'au bout, puis reprenez les questions
dans l'ordre.
Utilisez si possible les noms de variables et de fonctions donnés dans les
sujets pour rester compatible avec les solutions partielles qui vous seront
données.
Utilisez les fonctions qui accèdent aux données à chaque fois que
c'est possible, plutôt que d'accéder aux données directement.
Créez un répertoire TP1 sur votre compte,
dans lequel vous recopierez tous les fichiers sources
à la fin du TP.
V. Les données
Les produits seront stockés de la manière suivante :
un exemplaire de produit sera alloué par l'entité possédant le
stock ; l'adresse de cet exemplaire sera passé à la fonction
stocker qui la mémorisera dans un tableau rails
(un rail correspond à une sorte de produit) ;
lors de l'appel à stocker, la quantité de chaque produit sera
également passée en paramètre et mémorisée dans un tableau
quantites.
Les deux tableaux sont "parallèles" car ils ont le même nombre de cases
utilisées, et le nombre présent dans la case i de
quantites correspond à la quantité du produit dont l'adresse est
dans la case i de rails (voir dessin ci-dessous).
La variable index représente le nombre de sortes de
produits présentes dans le stock, c'est-à-dire le nombre de cases
occupées dans chacun des tableaux rails et quantites.
Mais il est intéressant de constater que la variable index
représente aussi le numéro de la première case libre de chacun
des deux tableaux (voir dessin ci-dessous).
index rails indices quantites
+-----+ +-------+ +-------+ +-------+
| 2 | | 'U' |<-------+---* | 0 | 4 |
+-----+ +-------+ +-------+ +-------+
+---+---* | 1 | 10 |
+-------+ | +-------+ +-------+
| 'D' |<---+ | ? | 2 | ? |
+-------+ +-------+ +-------+
| ? | 3 | ? |
+-------+ +-------+
| ? | 4 | ? |
+-------+ +-------+
Situation obtenue après le programme de test fourni
(voir TESTSTOC.INC).
VI. Les fonctionnalités à programmer
- initialiseur init_stock() :
Positionner le nombre de sortes de produits à 0.
- accesseur nb_sortes() :
Retourne le nombre de sortes de produits actuellement stockés.
- accesseur nb_unites(num_produit) :
Retourne le nombre d'unités actuellement stockées du produit
dont le numéro est passé en paramètre, ou
ERR_INTERVALLE .
- accesseur ieme(num_produit) :
Retourne l'adresse du produit dont le numéro est passé en
paramètre, ou ERR_INTERVALLE
(comment résoudre le problème de compilation ?) .
- fonction d'état est_vide(num_produit) :
Retourne VRAI s'il ne reste plus d'unités du produit dont le
numéro est passé en paramètre, FAUX sinon, ou
ERR_INTERVALLE .
- fonction d'état est_plein(num_produit) :
Retourne VRAI si le nombre d'unités du produit dont le numéro est
passé en paramètre est supérieur ou égal à
MAX_QUANTITE, FAUX sinon, ou
ERR_INTERVALLE .
- fonction d'état est_limite() :
Retourne VRAI si le nombre d'unités d'au moins un produit est
inférieur à un seuil (SEUIL) à fixer en constante
dans STOCK.H (2 par exemple), FAUX sinon.
- Faire un essai de compilation (sans link) pour corriger les
premières erreurs de syntaxe.
- fonction stocker(adr_produit,quantite) :
- Recherche dans le stock le produit en question à l'aide de la
fonction rechercher(adr_produit) qui sera définie
plus loin.
- Si le produit existe déjà dans le stock :
- si le "rail" de ce produit est déjà plein,
retourne ERR_PLEIN ;
- si l'ajout de la quantité va provoquer un dépassement de
capacité, retourne ERR_DEP ;
- stocke la quantité donnée et retourne OK.
- Sinon (si le produit n'est pas encore présent dans le stock) :
- si le maximum de sortes est déjà atteint, retourne
ERR_PLEIN ;
- "crée" une nouvelle sorte de produit, stocke la quantité
donnée, et retourne OK, ou ERR_DEP si on dépasse
MAX_QUANTITE .
- fonction retirer(num_produit) :
S'il n'y a plus de ce produit, retourne le résultat de l'appel de
la fonction traite_vide(num_produit)
(définie ci-dessous) ;
sinon, retire une unité de produit et retourne OK.
- fonction traite_vide(num_produit) :
Pour l'instant, se contente de retourner ERR_VIDE .
(Comment éviter simplement le warning à la compilation ?)
- utilitaire rechercher(adr_produit) :
Parcourt l'ensemble des produits et retourne le numéro du produit
dont l'adresse est celle passée en paramètre.
Retourne ERR_INCONNU si le produit n'est pas trouvé.
VII. Les tests
- STOCK.CPP doit inclure STOCK.H et TESTSTOC.INC .
Ce dernier fichier contient du code, et n'est inclus que pour ce
premier TP "non orienté objet".
- Il suffit de compiler puis lier (Build) STOCK.CPP pour construire
l'exécutable.
- Il est possible, lorsqu'on est dans la fenêtre STOCK.CPP,
de choisir Execute dans le menu Build,
ce qui lance la compilation (si besoin est),
l'édition de liens (si besoin est), et l'exécution du programme.
- Le programme doit afficher:
nb sortes = 0
sortes, unite's(0), plein(0) = 1, 4, 0
sortes, unite's(1), plein(1) = 2, 10, 1
vide(0,1),limite = 0, 0, 0
retirer ERR = 2
vide(0,1),limite = 1, 0, 1
VIII. Travail personnel
Il est indispensable que ce travail soit fait AVANT le prochain TP.
- Relisez les 3 fichiers afin de bien comprendre comment fonctionne
la gestion de stock.
- Corrigez et/ou complétez ce qui doit l'être pour qu'il n'y ait
plus aucune erreur ni aucun warning et que le programme de test
tourne parfaitement et donne les résultats attendus.
- Terminez les exercices 2, 3 et 4 de la fin du polycopié
d'introduction à la programmation orientée objet en C++.
Vérifiez ensuite votre travail par rapport au corrigé du TD1.
IX. TESTSTOC.INC
// TESTSTOC.INC
// Programme de test de Stock (a` inclure)
// sera transforme' en .CPP lors du deuxie`me TP
#include <iostream.h>
int main()
{
int err;
char * p;
init_stock();
cout << "nb sortes = " << nb_sortes() << endl;
p = new char( 'U' );
if ((err=stocker( p, 4 )) != OK)
cout << "stocker ERR = " << err << endl;
if (*p != 'U')
cout << "Probleme dans: stocker" << endl;
cout << "sortes, unite's(0), plein(0) = " << nb_sortes() << ", "
<< nb_unites( 0 ) << ", " << est_plein( 0 ) << endl;
p = new char( 'D' );
if ((err=stocker( p, 10 )) != OK)
cout << "stocker ERR = " << err << endl;
if (*p != 'D')
cout << "Probleme dans: stocker" << endl;
cout << "sortes, unite's(1), plein(1) = " << nb_sortes() << ", "
<< nb_unites( 1 ) << ", " << est_plein( 1 ) << endl;
if ( nb_unites(-1) != ERR_INTERVALLE ||
nb_unites( 2) != ERR_INTERVALLE )
cout << "methode nb_unites incorrecte." << endl;
if (p != ieme( 1 ) || (int)ieme(-1) != ERR_INTERVALLE
|| (int)ieme( 2) != ERR_INTERVALLE)
cout << "methode ieme incorrecte." << endl;
if ( est_vide(-1) != ERR_INTERVALLE ||
est_vide( 2) != ERR_INTERVALLE )
cout << "methode est_vide incorrecte." << endl;
if ( est_plein(-1) != ERR_INTERVALLE ||
est_plein( 2) != ERR_INTERVALLE )
cout << "methode est_plein incorrecte." << endl;
if ( retirer(-1) != ERR_INTERVALLE || retirer( 2) != ERR_INTERVALLE )
cout << "methode retirer incorrecte." << endl;
cout << "vide(0,1),limite = " << est_vide( 0 ) << ", "
<< est_vide( 1 ) << ", " << est_limite() << endl;
for ( int i=0; i<4+1; i++ )
if ((err=retirer( 0 )) != OK)
cout << "retirer ERR = " << err << endl;
cout << "vide(0,1),limite = " << est_vide( 0 ) << ", "
<< est_vide( 1 ) << ", " << est_limite() << endl;
return 0;
} // main
X. STOCK.H
// STOCK.H
// De'claration des fonctions de Stock
typedef char elem; // seulement pour le premier TP
// Constantes
const int FAUX = 0;
const int VRAI = 1;
const int MAX_SORTES = 5;
const int MAX_QUANTITE = 10;
const int ERR_INCONNU = -2;
const int ERR_INTERVALLE = -1;
const int OK = 0;
const int ERR_PLEIN = 1;
const int ERR_VIDE = 2;
const int ERR_DEP = 3;
// Initialiseur
void init_stock();
// Accesseurs
int nb_sortes();
int nb_unites( int );
elem* ieme( int );
// Fonctions d'e'tat
int est_vide( int );
int est_plein( int );
int est_limite();
// Autres fonctions
int stocker( elem*, int );
int retirer( int );
int traite_vide( int );
// Fonction utilitaire
int rechercher( elem* );
// Donne'es
int index;
int quantites[MAX_SORTES];
elem* rails[MAX_SORTES];
File translated from
TEX
by
TTH,
version 2.75.
On 19 Nov 2001, 11:53.