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

II.  Notions abordées dans les cours 0 et 1

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

  1. initialiseur init_stock() :
    Positionner le nombre de sortes de produits à 0.
  2. accesseur nb_sortes() :
    Retourne le nombre de sortes de produits actuellement stockés.
  3. 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 .
  4. 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 ?) .
  5. 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 .
  6. 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 .
  7. 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.
  8. Faire un essai de compilation (sans link) pour corriger les premières erreurs de syntaxe.
  9. fonction stocker(adr_produit,quantite) :
  10. 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.
  11. fonction traite_vide(num_produit) :
    Pour l'instant, se contente de retourner ERR_VIDE . (Comment éviter simplement le warning à la compilation ?)
  12. 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

  1. 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".
  2. Il suffit de compiler puis lier (Build) STOCK.CPP pour construire l'exécutable.
  3. 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.
  4. 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.

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.