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.

[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.)

[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 ?

[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 :

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

1
2
3
4
 
  Date LaDate;
// ou plutôt
  Date dateNaissance;

A vois de deviner où.

[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

[atttchoum]

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)

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

tu es sur la bonne voie

[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.