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.