Discussion :

[Elixx]

Bonjour, je dois modifier un programme déjà fait, à partir de ce problème suivant:

"Modifiez le système de paie de la figure 10.1 pour ajouter les membres de donnéees private appelés
dateNaissance (un objet Date) et codeDpeartement (de type int) à la classe Employe.
Présumez que la paie est traitée une fois par mois. Ensuite, alors que votre programme calcule la rémunération
pour chaque Employe (en utilisant le polymorphisme), ajoutez une prime de 100.00$ au mantant de la paie
de la personne si le mois correspond à celui de l'anniversaire de naissance de l'Employe. "

Voici le code (désolé, c'est un peu long):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Fig. 10.1: employe2.h
// Classe de base abstraite Employe.
#ifndef EMPLOYE2_H
#define EMPLOYE2_H
 
class Employe {
public:
   Employe( const char *, const char * );
   ~Employe();   // destructeur réclamant de la mémoire.
   const char *lecturePrenom() const;
   const char *lectureNomFamille() const;
 
// Fonction virtuelle pure produisant la classe de base abstraite Employe.
   virtual double gains() const = 0;   // virtuelle pure.
   virtual void affichage() const;     // virtuelle.
private:
   char *prenom;
   char *nomFamille;
};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>
using std::cout;
#include <cstring>
#include <cassert>
#include "employe2.h"
 
// Le constructeur alloue de l'espace dynamique pour les
// prénoms et noms de famille et utilise strcpy pour copier
// les prénoms et noms de famille dans l'objet.
Employe::Employe( const char *premier, const char *dernier )
{
   prenom = new char[ strlen( premier ) + 1 ];
   assert( prenom != 0 );     // teste si new a fonctionné.
   strcpy( prenom, premier );
 
   nomFamille = new char[ strlen( dernier ) + 1 ];
   assert( nomFamille != 0 ); // teste si new a fonctionné.
   strcpy( nomFamille, dernier );
 
}
 
// Le destructeur désalloue la mémoire dynamique.
Employe::~Employe()
{
   delete [] prenom;
   delete [] nomFamille;
}
 
 
 
// Renvoie un pointeur vers le prénom. Un renvoi de type const empêche
// l'appelant de modifier les données private. L'appelant doit copier
// la chaîne renvoyée avant que le destructeur ne supprime la mémoire
// dynamique pour empêcher la formation d'un pointeur non défini.
const char *Employe::lecturePrenom() const
{ 
   return prenom;   // l'appelant doit supprimer la mémoire.
}
 
// Renvoie un pointeur vers le nom de famille. Un type de renvoi const
// empêche l'appelant de modifier les données private. L'appelant doit
// copier la chaîne renvoyée avant que le destructeur ne supprime la
// mémoire dynamique pour empêcher la formation d'un pointeur non défini.
const char *Employe::lectureNomFamille() const
{
   return nomFamille; // l'appelant doit supprimer la mémoire.
}
 
// Affiche le nom de l'Employe.
void Employe::affichage() const
   { cout << prenom << ' ' << nomFamille; }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Fig. 10.1: patron1.h
// Classe Patron, dérivée de la classe Employe.
#ifndef PATRON1_H
	#define PATRON1_H
#include "employe2.h"
 
class Patron: public Employe {
public:
   Patron( const char *, const char *, double = 0.0 );
   void ajusterSalaireHebdo( double );
   virtual double gains() const;
   virtual void affichage() const;
private:
   double salaireHebdo; 
};
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Fig. 10.1: patron1.cpp
// Définitions des fonctions membres pour la classe Patron.
#include <iostream>
using std::cout;
#include "patron1.h"
// Fonction constructeur pour la classe Patron.
Patron::Patron( const char *premier, const char *dernier, double s )
  : Employe( premier, dernier ) // appelle constructeur de classe de base.
{ ajusterSalaireHebdo( s ); }
 
// Ajuste le salaire du Patron.
void Patron::ajusterSalaireHebdo( double s )
   { salaireHebdo = s > 0 ? s: 0; }
 
// Lit la paie du Patron.
double Patron::gains() const { return salaireHebdo; }
 
// Affiche le nom du Patron.
void Patron::affichage() const
{
   cout << "\n                 Patron: ";
   Employe::affichage();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Fig. 10.1: commis1.h
// Classe EmployeCommission, dérivée de la classe Employe.
#ifndef COMMIS1_H
#define COMMIS1_H
#include "employe2.h"
 
class EmployeCommission: public Employe {
public:
   EmployeCommission( const char *, const char *,
                      double = 0.0, double = 0.0,
                      int = 0 );
   void ajusterSalaire( double );
   void ajusterCommission( double );
   void ajusterQuantite( int );
   virtual double gains() const;
   virtual void affichage() const;
private:
   double salaire;      // salaire hebdomadaire de base.
   double commission;   // montant par article vendu.
   int quantite;        // total d'articles vendus pour la semaine.
};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// Fig. 10.1: commis1.cpp
// Définitions des fonctions membres pour la classe EmployeCommission.
#include <iostream>
using std::cout;
#include "commis1.h"
 
// Constructeur pour la classe EmployeCommission.
EmployeCommission::EmployeCommission( const char *premier,
        const char *dernier, double s, double c, int q )
  : Employe( premier, dernier ) // appelle constructeur de classe de base.
{
   ajusterSalaire( s );
   ajusterCommission( c );
   ajusterQuantite( q );
}
 
 
 
 
 
 // Ajuste le salaire de base hebdo de l'EmployeCommission.
void EmployeCommission::ajusterSalaire( double s ) 
   { salaire = s > 0 ? s: 0; }
 
// Ajuste la commission de l'EmployeCommission.
void EmployeCommission::ajusterCommission( double c )
   { commission = c > 0 ? c: 0; }
 
// Ajuste la quantité vendue de l'EmployeCommission.
void EmployeCommission::ajusterQuantite( int q )
   { quantite = q > 0 ? q: 0; }
 
// Détermine les gains de l'EmployeCommission.
double EmployeCommission::gains() const
   { return salaire + commission * quantite; }
 
// Affiche le nom de l'EmployeCommission.
void EmployeCommission::affichage() const
{
   cout << "\n   Employé à commission: ";
   Employe::affichage();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Fig. 10.1: piece1.h
// Classe EmployePiece, dérivée de la classe Employe.
#ifndef PIECE1_H
#define PIECE1_H
#include "employe2.h"
 
class EmployePiece: public Employe {
public:
   EmployePiece( const char *, const char *, 
                double = 0.0, int = 0);
   void ajusterPaie( double );
   void ajusterQuantite( int );
   virtual double gains() const;
   virtual void affichage() const;
private:
   double tauxParPiece; // taux pour chaque pièce produite.
   int quantite;        // quantité produite pour la semaine.
};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Piece1.cpp
#include <iostream>
using std::cout;
#include "piece1.h"
// Constructeur
EmployePiece::EmployePiece( const char *premier, const char *dernier,
			   double w, int q )
  : Employe( premier, dernier )
{
	ajusterPaie( w );
	ajusterQuantite( q );
}
// Ajuste la paie.
void EmployePiece::ajusterPaie( double w )
	{ tauxParPiece = w > 0 ? w: 0; }
// Ajuste le nombre d’article produits.
void EmployePiece::ajusterQuantite( int q )
	{ quantite = q > 0 ? q: 0; }
// Determine les gains de l’EmployePiece.
double EmployePiece::gains() const
	{ return quantite * tauxParPiece; }
// Affiche le nom de l’EmployePiece.
void EmployePiece::affichage() const
	{ cout << "\n     Employé payé à la pièce: ";
	  Employe::affichage();
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Fig. 10.1: horaire1.h
// Définition de la classe EmployeHoraire.
#ifndef HORAIRE1_H
#define HORAIRE1_H
#include "employe2.h"
 
class EmployeHoraire: public Employe {
public:
   EmployeHoraire( const char *, const char *, 
                 double = 0.0, double = 0.0);
   void ajusterPaie( double );
   void ajusterHeures( double );
   virtual double gains() const;
   virtual void affichage() const;
private:
   double tauxHoraire; // taux horaire.
   double heures;      // heures travaillées pour la semaine.
};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Fig. 10.1: horaire1.cpp
// Définitions des fonctions membres pour la classe EmployeHoraire.
#include <iostream>
using std::cout;
#include "horaire1.h"
 
// Constructeur pour la classe EmployeHoraire.
EmployeHoraire::EmployeHoraire( const char *premier, 
                                const char *dernier,
                                double w, double h )
  : Employe( premier, dernier ) // appelle constructeur de classe de base.
{
   ajusterPaie( w );
   ajusterHeures( h );
}
 
 
 
 
 
 
// Ajuste le taux horaire.
void EmployeHoraire::ajusterPaie( double w ) 
   { tauxHoraire = w > 0 ? w: 0; }
 
// Ajuste les heures travaillées.
void EmployeHoraire::ajusterHeures( double h )
   { heures = h >= 0 && h < 168 ? h: 0; }
 
// Lit la paie de l'EmployeHoraire.
double EmployeHoraire::gains() const 
{ 
   if ( heures <= 40 ) // pas de temps supplémentaire.
      return tauxHoraire * heures;
   else                // temps supplémentaire = temps et demi.
      return 40 * tauxHoraire + ( heures - 40 ) * tauxHoraire * 1.5;
}
 
// Affiche le nom de l'EmployeHoraire.
void EmployeHoraire::affichage() const
{
   cout << "\n        Employé horaire: ";
   Employe::affichage();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// Figure 10.1: fig10_01.cpp
// Pilote pour la hiérarchie de la classe Employe.
#include <iostream>
 
using std::cout;
using std::endl;
#include <iomanip>
using std::ios;
using std::setiosflags;
using std::setprecision;
 
#include "employe2.h"
#include "patron1.h"
#include "commis1.h"
#include "piece1.h"
#include "horaire1.h"
 
void virtuelViaPointeur( const Employe * );
void virtuelViaReference( const Employe & );
 
 
 
 
 
 
 
int main()
{
   // Ajuste le formatage de sortie.
   cout << setiosflags( ios::fixed | ios::showpoint ) 
        << setprecision( 2 );
 
   Patron b( "Jean", "Soucy", 800.00 );
   b.affichage();                         // liage statique.
   cout << " a gagné $" << b.gains();     // liage statique.
   virtuelViaPointeur( &b );  // utilise le liage dynamique.
   virtuelViaReference( b );  // utilise le liage dynamique.
 
   EmployeCommission c( "Lise", "Jobin", 200.0, 3.0, 150 );
   c.affichage();                         // liage statique.
   cout << " a gagné $" << c.gains();     // liage statique.
   virtuelViaPointeur( &c );  // utilise le liage dynamique.
   virtuelViaReference( c );  // utilise le liage dynamique.
 
   EmployePiece p( "Benoit", "Cyr", 2.5, 200 );
   p.affichage();                         // liage statique.
   cout << " a gagné $" << p.gains();     // liage statique.
   virtuelViaPointeur( &p );  // utilise le liage dynamique.
   virtuelViaReference( p );  // utilise le liage dynamique.
 
 
 
 
 
 
 EmployeHoraire h( "Karine", "Roy", 13.75, 40 );
   h.affichage();                         // liage statique.
   cout << " a gagné $" << h.gains();     // liage statique.
   virtuelViaPointeur( &h );  // utilise le liage dynamique.
   virtuelViaReference( h );  // utilise le liage dynamique.
   cout << endl;
   return 0;
}
 
// Permet à la fonction virtuelle d'appeler un pointeur
// de la classe de base en utilisant le liage dynamique.
void virtuelViaPointeur( const Employe *classeBasePtr )
{
   classeBasePtr->affichage();
   cout << " a gagné $" << classeBasePtr->gains();
}
 
// Permet à la fonction virtuelle d'appeler une référence
// de la classe de base en utilisant le liage dynamique.
void virtuelViaReference( const Employe &classeBaseRef )
{
   classeBaseRef.affichage();
   cout << " a gagné $" << classeBaseRef.gains();
}

Est-ce que quelqu'un pourrait me guider un peu? Je ne vois pas trop quoi faire.
Où ajouter quoi, et comment...
Merci d'avance.