I.  Les objectifs

• Concevoir une hiérarchie de classes.
• Rendre le monnayeur du TP2 plus réaliste en lui faisant gérer stock de pièces.
• Utiliser l'héritage pour ne pas avoir à récrire toutes les méthodes de la classe Stock.

II.  Notions abordées dans le cours 3

• La notion d'héritage.
• La dérivation publique.
• Le mode d'accès "protégé".
• La gestion des constructeurs dans une hiérarchie.
• La transmission d'arguments au constructeur de la classe de base.

III.  Références dans les documents

IV.  Conseils généraux

Appelez un intervenant dès que quelquechose ne semble pas clair dans le sujet ou si, après avoir réfléchi, vous ne trouvez pas la solution.

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.

Créez deux fichiers pour chaque classe, et "déclarez" dans le .H et "définissez" dans le .CPP.

Empêchez systématiquement les éventuelles inclusions multiples, déclarez les fonctions 'public', et déclarez les données 'private' et les fonctions 'const' à chaque fois que c'est possible.

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 sur C: un répertoire TP3 et des sous-répertoires pour chaque exercice. N'oubliez pas de recopier tous les fichiers sources sur votre compte à la fin du TP.

V.  Exercice 1 (sans rapport avec le distributeur)

1. Créer un nouveau projet TESTPOIN.
   • Définir une classe Point contenant :
     • deux coordonnées entières x et y
     • un constructeur à deux arguments
     • une procédure affiche() ; exemple de format d'affichage : (2,-1)
     • une procédure deplace() à deux arguments représentant le décalage en X et en Y
   • Compiler (sans link), et corriger les erreurs de syntaxe.
   • Récupérer le fichier TESTPOIN.CPP pour l'ajouter au projet.
   • Construire l'exécutable et vérifier les affichages.
2. Créer un nouveau projet TESTPCOL et y recopier la classe Point.
   • Définir une classe Pointcol héritant de Point contenant :
     • un caractère couleur ('W', 'R', 'G', 'B', par exemple)
     • un constructeur à trois arguments transmettant les deux premiers au constructeur de Point et prenant 'W' par défaut pour le 3ème
     • une procédure colore() à un argument char qui modifiera la couleur du point
     • une procédure affiche() qui affichera le caractère couleur puis ':', puis appellera la procédure affiche() de la classe Point
   • Compiler (sans link), et corriger les erreurs de syntaxe.
   • Récupérer le fichier TESTPCOL.CPP pour l'ajouter au projet.
   • Construire l'exécutable et vérifier les affichages.
3. Créer un nouveau projet TESTPCDI et y recopier les classes Point et Pointcol.
   • Définir une classe Pcoldiag héritant de Pointcol ; un tel point aura forcément une abscisse et une ordonnée identiques et forcément la couleur 'D' ; la classe contient :
     • un constructeur à un seul argument qui forcera les deux coordonnées à cette même valeur et la couleur à 'D'
     • une procédure colore() à un argument char (pourquoi ?) qui interdira la modification de la couleur
   • Compiler (sans link), et corriger les erreurs de syntaxe.
   • Récupérer le fichier TESTPCDI.CPP pour l'ajouter au projet.
   • Construire l'exécutable et vérifier les affichages.

VI.  Exercice 2 (Distributeur)

On désire maintenant améliorer le fonctionnement du monnayeur pour qu'il gère un stock de pièces. Ainsi, il ne pourra rendre indéfiniment la monnaie, ce qui est plus proche de la réalité.

Pour ne pas avoir à refaire la gestion d'un stock, il faut rendre la classe Stock indépendante de Produit, créer une classe Piece, puis utiliser la classe Stock dans le monnayeur pour gérer un stock de pièces et dans le distributeur pour gérer un stock de produits.

1. Récupérer les fichiers ELEM.H, PIECE.H et PIECE.CPP, et les comprendre.
2. Modifier PRODUIT.H pour le faire hériter de la classe elem (aucune modification à l'intérieur de la classe n'est nécessaire).
3. Modifier STOCK.H pour le rendre indépendant de Produit : inclure ELEM.H pour remplacer la définition d' elem (aucune modification à l'intérieur de la classe n'est nécessaire).
4. Créer une classe Stock_produits qui prendra la place de l'ancienne classe Stock dans le distributeur. Cette classe hérite, bien entendu, de Stock et est vide pour le moment, si ce n'est l'inclusion souhaitable de la classe Produit.
5. Créer une classe Stock_pieces qui servira au monnayeur. Cette classe hérite, bien entendu, de Stock et est, pour l'instant, vide, si ce n'est l'inclusion souhaitable de la classe Piece.
6. Adapter le distributeur pour qu'il utilise Stock_produits. Adapter le monnayeur pour qu'il utilise Stock_pieces (notamment, changer le comportement de rendre_monnaie(), n'accepter que la somme exacte quand le stock de pieces est_limite(), et prévoir des limites dégressives suivant la valeur de la pièce.
7. Tout retester, puis tout sauvegarder.

VII.  TESTPOIN.CPP

// TESTPOIN.CPP
//
#include <iostream.h>
#include "point.h"

int main()
  {
  Point  p1( -1, -3 ),          p2( 2, 4 );
         p1.affiche();          p2.affiche();
         p2.deplace( -5, 5 );   p2.affiche();
  return 0;
  }
/*
DEVRAIT AFFICHER : (-1,-3) (2,4) (-3,9)
*/
 

VIII.  TESTPCOL.CPP

// TESTPCOL.CPP
//
#include <iostream.h>
#include "pointcol.h"

int main()
  {
  Pointcol  pc1( 1, 1, 'R' ),       pc2( 2, 2 );
            pc1.affiche();          pc2.affiche();
            pc2.colore( 'G' );      pc2.affiche();
            pc2.deplace( -5, 5 );   pc2.affiche();
  return 0;
  }
/*
DEVRAIT AFFICHER : R:(1,1) W:(2,2) G:(2,2) G:(-3,7)
*/
 

IX.  TESTPCDI.CPP

// TESTPCDI.CPP
//
#include <iostream.h>
#include "pointcol.h"
#include "pcoldiag.h"

int main()
  {
  Pointcol pc1( 7, 8, 'C' );     Pcoldiag pcd2( -5 );
           pc1.affiche();                 pcd2.affiche();
           pc1.colore( 'G' );             pcd2.colore( 'G' );
           pc1.affiche();                 pcd2.affiche();
                                          pcd2.deplace( -5, 5 );
                                          pcd2.affiche();
  return 0;
  }
/*
DEVRAIT AFFICHER :
  C:(7,8) D:(-5,-5) G:(7,8) D:(-5,-5) D:(-10,0)
*/
 

X.  ELEM.H

// ELEM.H
// Classe vide dont on peut he'riter

#ifndef _ELEM_H
#define _ELEM_H
class elem {};
#endif
 

XI.  PIECE.H

// piece.h
// De'claration de la classe Piece

#ifndef _piece_h // Pre'vention des inclusions multiples
#define _piece_h
#include "ELEM.H"

class Piece : public elem
{
public:
// Constructeur / Destructeur
	Piece( float Valeur );
	~Piece() { }
// Accesseurs
	float AccesValeur() const;

// Donne'es membres
private :
	float valeur;
};
#endif
 

XII.  PIECE.CPP

// piece.cpp
// De'finition des fonctions membres de la classe Piece
#include "piece.h"

// Constructeur
Piece::Piece( float V )
  {
  valeur = V;
  }

// Accesseur
float Piece::AccesValeur() const
  {
  return valeur;
  }