Difficulté avec un problème de polymorphisme

Version imprimable

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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.

08/06/2010, 09h54
atttchoum

Bonjour,

Qu'est-ce que tu ne comprend pas exactement ?
Est-ce que tu comprend par exemple ce que fait le programme et pourquoi ? (je parle notamment du passage par référence et par adresse.)
08/06/2010, 17h15
Elixx

Je vois pas trop où ajouter dateNaissance et comment le mettre dans le programme. (et de ce qu'il parle par un objet de "date") en autre...
Si je ne me trompe pas, ce serait dans employe.h mais c'est quoi un objet de date ?
08/06/2010, 17h31
Invité
Bonjour,
Où avez-vous lu "un objet de date".
Il est écrit "un objet Date". Cela signifie un objet qui représente une date, et que l'on va nommer "Date", ou que son type de définition s'appellera Date.
Quelque-part il y aura une ligne qui ressemblera à ceci
Code:

1 2 3 4 Date LaDate; // ou plutôt Date dateNaissance;
A vois de deviner où.
08/06/2010, 17h37
beni46

Il parle d'un objet "Date" c'est à dire qu'il te demande de créer un objet (une classe) qui permet de gérer une date (récupérer la date courante, etc...).

C'est comme ça que je le vois mais sinon demande à ton prof ^^.

Bye
08/06/2010, 18h06
atttchoum

Citation:

Envoyé par beni46

Il parle d'un objet "Date" c'est à dire qu'il te demande de créer un objet (une classe) qui permet de gérer une date (récupérer la date courante, etc...).

C'est comme ça que je le vois mais sinon demande à ton prof ^^.

Bye

Si c'est pour un exercice qui n'est pas destiné a être compilé je doute qu'ici son prof s'intéresse a l'implémentation du type date (enfin je dis ça...).

Comme l'a dis Pierre Dolez je pense qu'il te suffit de rajouter un membre de type Date (ainsi qu'un membre codeDepartement de type int)

Citation:

Si je ne me trompe pas, ce serait dans employe.h

tu es sur la bonne voie :ccool:
09/06/2010, 12h54
eyquem

Bonjour,

J’ai été pour le moins ébahi, en consultant hier les “Derniers messages“, de tomber sur le code présenté dans le premier post. Je le trouve très long. Je ne dis pas extrèmement long, mais très long tout de même.

La présentation du code sous forme fragmentée en 11 sections y est pour quelque chose.
En éliminant toutes les lignes de commentaire pur et les lignes ne contenant que ’}’ ou ’{’ ou ’};’ , on obtient aussi un code d’étendue moins impressionante.

Il n’en reste pas moins que j’ai compté les lignes significatives (celles restant après l’élimination que je viens de dire): 172 lignes.
Pour ma perception , cela reste un nombre élevé de lignes relativement à la nature du code (“système de paie “) et des 2 opérations qu’il est demandé d’additionner au code ( “ajouter les membres de donnéees private appelés
dateNaissance et codeDpeartement à la classe Employe.“,
“, “ajoutez une prime de 100.00$ au mantant de la paie
de la personne si ...“)

Ceci me suscite quelques questions:

- eu égard au sujet énoncé, le code présenté est-il algorithmiquement bien conçu ?

Ce que je voudrais savoir c’est si des spécialistes de C++ considèrent que le nombre de lignes de ce code est plus ou moins incompressible parce qu’on ne peut envisager d’autre coneption pour répondre aux besoins énoncés, ou si le nombre de lignes est excessif parce que le code est médiocre ?

- qu’est ce qui justifie l’utilisation de C++ pour créer un système informatisé de paie ?

Je trouve pour ma part que c’est se donner beaucoup de mal avec un langage compliqué à apprendre et à utiliser pour faire quelque chose qui n’exige pas, me semble-t-il, la vitesse de calcul qu’apporte le C++.

- il m’intéresserait de connaître la liste synthétique des opérations que ce système de paie est destiné à assurer.
Je vois les suivantes dans le code mais c’est trop détaillé:

// 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.
// Affiche le nom de l'Employe.
// Ajuste le salaire du Patron.
// Lit la paie du Patron.
// Affiche le nom du Patron.
// Ajuste le salaire de base hebdo de l'EmployeCommission.
// Ajuste la commission de l'EmployeCommission.
// Ajuste la quantité vendue de l'EmployeCommission.
// Détermine les gains de l'EmployeCommission.
// Affiche le nom de l'EmployeCommission.
// Ajuste la paie.
// Ajuste le nombre d’article produits.
// Determine les gains de l’EmployePiece.
// Affiche le nom de l’EmployePiece.
// Ajuste le taux horaire.
// Ajuste les heures travaillées.
// Lit la paie de l'EmployeHoraire.
// Affiche le nom de l'EmployeHoraire.
// Ajuste le formatage de sortie.
// Permet à la fonction virtuelle d'appeler un pointeur de la classe de base en utilisant le liage dynamique.

- comment sont conservés les données ? dans une BDD ? autre ?

strcopy copie des données dans l’objet, mais je ne comprends pas à partir de quoi. À partir de ce qu’on tape à l’écran ?

Merci pour toute réponse.
13/06/2010, 18h59
nikko34

une partie du code est compliquée parce qu'il utilise des char * à la place de la classe simple std::string (tu pourras en parler à un prof).

Et puis sinon, le C++ bien utilisé n'est pas plus compliqué à comprendre qu'un autre langage.
14/06/2010, 10h07
vingt sens

@eyquem:
Je pense qu'il faut tout d'abord voir qu'il s'agit d'un cas d'école. On demande à l'étudiant de comprendre les bases du C++. Rien de plus...

Citation:

- eu égard au sujet énoncé, le code présenté est-il algorithmiquement bien conçu ?

personnellement, je ne vois d'algo là dedans... Il s'agit juste d'un exemple de hiérarchie de classe. on a Patron, EmployeCommission, EmployePiece et EmployeHoraire qui descendent d'Employe... Cela me semble cohérent: différentes classes d'individus payés de différentes façons.

Citation:

- qu’est ce qui justifie l’utilisation de C++ pour créer un système informatisé de paie ?

Tout langage peut être utilisé pour créer un système de paie. Je pense qu'aujourd'hui, en entreprise, on aurait tendance à utilisé le J2EE et certainement des applications clef-en-main. Une application Java déportée utilisant des Bases de Données... Mais l'implémentation de base pourrait être celle de l'exercice.

Citation:

- comment sont conservés les données ?

Les données ne sont pas tout simplement pas conservés.

@nikko34

Citation:

une partie du code est compliquée parce qu'il utilise des char * à la place de la classe simple std::string

Quand j'ai appris le C++ en cours, je n'ai pas vu le 'std::string': ce doit pour ne pas perturbé l'élève. L'élève vient de sortir du C doit apprendre le C++. Mais pour l'instant ne connait pas vraiment les bases. Lui faire utiliser des classes doit être considéré comme un peu prématuré.
14/06/2010, 10h38
nikko34

Citation:

Quand j'ai appris le C++ en cours, je n'ai pas vu le 'std::string': ce doit pour ne pas perturbé l'élève. L'élève vient de sortir du C doit apprendre le C++. Mais pour l'instant ne connait pas vraiment les bases. Lui faire utiliser des classes doit être considéré comme un peu prématuré.

eh bien std::string est bien plus simple que char*. Autant commencer par les bonnes pratiques non?

Pourquoi les classes ça serait simple en Java et compliqué en C++?
14/06/2010, 11h11
vingt sens

Citation:

eh bien std::string est bien plus simple que char*. Autant commencer par les bonnes pratiques non?

d'accord avec toi, c'est peu être pour éviter de voir du C++ dans du C... J'ai déjà vu des applications avec ce type de code... c'est à s'étrangler... et ça me donne l'impression que les personne ne savent pas ce qu'ils font.

Citation:

Pourquoi les classes ça serait simple en Java et compliqué en C++?

A mon sens c'est quasiment la même chose. Les applications déportés en J2EE ont une syntaxe particulière qui permettent de les lier directement à des Bases de Donnée. J'ai eu des cours d' 'Architecture Logiciel' qui consistaient à l'énumération des méthodes pour obtenir des applications sur server ayant les mêmes fonctionnalités. Je n'aime pas trop cette technologie qui tient à mon gout à du bidouillage (trop de chose cachée) et je préfère 100x le C++.

Il faudrait vérifier sur un site de recherche d'emploi, mais je pense que la compétence J2EE est plus recherché que C++. Du moins dans les grosses boites en informatiques.
14/06/2010, 13h26
Klaim

Il me semble que pour la plupart des banques, la vitesse d'execution des transaction est pour le moins aussi importante que le fait qu'elles doivent être executées correctement.