Année académique 2023-2024

Classe: L2IT
Date : 19/12/2023
Date de remise : 18/01/2024
Enseignant: M. LOYA

MINI-PROJET DE C++
L’objectif de ce projet est de visiter les différentes notions vues dans le cours d’introduction au langage C++.

Première partie : Conception et définition de la classe CDate.

En première approche, une classe en POO permet de créer un type utilisateur, pouvant être utilisé dans des
programmes comme si c'était un type prédéfini. Ces programmes pourront déclarer et manipuler des variables de
ce type.
Dans cette partie, on s’intéresse à la classe CDate qui permettra de définir un type utilisateur et d'aborder les
premiers concepts de la POO sur un thème connu de tous : les dates.
Avant tout, il faut imaginer ce qu'un utilisateur pourra faire avec une date dans un programme : c'est l'interface,
qui en général pourra être mise dans un fichier en-tête (CDate.h) qui sera inclus dans le fichier utilisant la classe
CDate. Cette réflexion devra se faire sans tenir compte d'une implémentation, c'est à dire sans tenir compte
de la façon dont une date sera représentée en mémoire.
I. Conception de l'interface
L’interface d’une classe représente les services que ses objets peuvent offrir à leurs environnements extérieurs.
Pour déterminer l’interface de la classe CDate, il vaut se poser la question : Que pourra faire un utilisateur avec
un type CDate?

1. Déclaration d'une variable de type CDate: les constructeurs

Il faut prévoir comment l'utilisateur de la classe CDate va déclarer une variable et quelles initialisations mettre à
sa disposition? Rappelons que les déclarations de variables de classe (instances) se font par l'intermédiaire de
traitements spéciaux : les constructeurs.
On permettra ici à l'utilisateur les initialisations suivantes :
a) CDate d1;
Constructeur sans argument. Il initialisera d1 à une date quelconque (On choisit ici le 1er janvier 1970).
b) CDate d2(14,7,2003);
CDate d2(14,7) ; //d2<- - - (14, 7, 2012) ; 2012 : année en courant
CDate d2(14);//d2<- - - -(14, 11, 2012) ; on est novembre 2012
CDate(0);//d2<- - -aujourd’hui
Constructeur avec initialisation spécifique (ici, un triplet jour, mois, année donné).
Il faudra vérifier que ce triplet correspond bien à une date valide lors de la construction.
On permettra à l'utilisateur d'initialiser à la date système en permettant des valeurs spéciales pour ce constructeur :
si l'année est égale à 0, on prendra l'année courante, si le mois et l'année sont égaux à 0, on prendra le mois et
l'année courante, si les trois sont nuls, on prendra la date système.
c) CDate d3(d2);
CDate d3=d2;
Deux appels possibles pour le même constructeur (le constructeur de copie, permettant de déclarer une date tout
en l'initialisant par une autre date.

2. Consulter, pour une date, son numéro de jour, de mois, d'année

L'utilisateur de la classe CDate voudra certainement pouvoir disposer pour une date donnée de ses composants
jour, mois, année. On va donc mettre à la disposition de l’utilisateur des traitements de consultation du jour, du
mois et l’année d’une date. Il ne faut pas que ces traitements altèrent la date. Par exemple :
CDate d(12, 11, 2012);
d.lireJour() //renvoie 12
d.lireMois() //renvoie 11
d.lireAnnee() //renvoie 2012
1
3. Afficher une variable de type CDate à l'écran
Lorsque l'utilisateur de la classe CDate écrira des programmes avec des variables de type CDate, il aura besoin,
ne serait-ce que pour le débogage, d'afficher ces variables.
Il faut donc surcharger l’opérateur << dans la classe ostream afin de permettre à l’utilisateur l’affichage des
variables de type CDate.

4. Saisir au clavier une variable de type CDate

De même, l’utilisateur aura besoin de lire des variables de type CDate : Surcharger donc l’opérateur >> dans la
classe istream afin de permettre à l’utilisateur la saisie des variables de type CDate.

5. Comparer deux dates ==, !=, <, <=, >, >=

Savoir si deux dates sont identiques, si une date est inférieure à une autre, …., sera également une demande de
l'utilisateur qui voudra pouvoir écrire du code semblable à :
Date d1, d2;
// …
if (d1<d2)
{
// . . .
}
. . . .
On doit surcharger les opérateurs de comparaison classiques pour permettre la comparaison des dates CDate, sans
privilégier un opérande.

6. Affecter une date

Affecter une date CDate par une autre est une préoccupation de l’utilisateur. Il faut donc surcharger l’opérateur
d’affectation.

7. Faire de l'arithmétique sur les dates

Ajouter/soustraire (+, -) un certain nombre de jours à une date, calculer le nombre de jours entre deux dates(-),
modifier arithmétiquement une date (++d, d++, - -d, d- -, d+=n, d-=n,…) sont des utilisations possibles des dates
CDate.

8. Ajouter des périodes à une date

On pourra également permettre à un utilisateur de la classe CDate de faire de l'arithmétique sur d'autres périodes
que le jour (ajouter des semaines, mois, années).
Pour cela, on va définir dans CDate les types de périodes :
enum TYPE_PERIODE{JOUR, MOIS, SEMAINE, ANNEE};
L'accès à ces noms de l'extérieur de la classe CDate devra être préfixé par CDate::. Par exemple
CDate::SEMAINE.
A partir de cela, l’utilisateur pourra écrire par exemple le code suivant :
CDate d(12, 11, 2012);
d.ajouterPeriode(10, CDate ::JOUR)// renvoie la date 22/11/2012
d.ajouterPeriode(2, CDate ::SEMAINE)//renvoie la date 26/11/2012
d.ajouterPeriode(10, CDate ::MOIS)// renvoie la date 12/9/2013
d.ajouterPeriode(-10, CDate ::ANNEE)//renvoie la date 12/11/2002
CDate d(31, 5, 2012);
d.ajouterPeriode(1, CDate ::MOIS)//renvoie la date 30/6/2012
CDate d(29, 2, 2000);
d.ajouterPeriode(-3, CDate ::ANNEE)//renvoie la date 28/2/1997
Naturellement, ces traitements ne doivent pas modifier les dates les subissant.

9. Calculer un ou plusieurs formats texte correspondant à une date CDate.

De même, l'utilisateur de la classe CDate voudra certainement disposer de traitements lui permettant d'avoir en
texte l'équivalent d'une date. Par exemple :
2
 "Mar 28 Oct 2003"
"Mardi 28 Octobre 2003"
"28/10/2003"
"Mardi"
"Octobre"
Il faut donc définir les formats autorisés : enum FORMAT {MINIMAL, COMPLET, ABREGE};
et lui permettre de faire par exemple des utilisations :
CDate d(12, 11, 2012);
string s, j, m;
d.formater(s, CDate ::MINIMAL);//renvoie et place dans s, 12/11/2012
d.formater(s, CDate ::ABREGE);//renvoie et place dans s, Lun 12 Nov 2012
d.formater(s, CDate ::COMPLET);//renvoie et place dans s,Lundi 12 Novembre 2012

d.trouverNomJour(j, CDate ::MINIMAL);//renvoie et place dans j, Erreur

d.trouverNomJour(j, CDate ::ABREGE);//renvoie et place dans j,Lun
d.trouverNomJour(j, CDate ::COMPLET);//renvoie et place dans j, Lundi

d.trouverNomMois(m, CDate ::MINIMAL);//renvoie et place dans m, 11

d.trouverNomMois(m, CDate :: ABREGE);//renvoie et place dans m, Nov
d.trouverNomMois(m, CDate :: COMPLET);//renvoie et place dans m, Novembre
Ces traitements ne doivent pas également modifier les dates.
NB : Utiliser les classes stringstream et ostringstream pour les conversions ou de préférence les
fonctions de conversion stoi, stol, stof, stod, to_string, …

10. Autres utilisations

Laissez parler votre imagination, en proposant d’autres utilisations possibles.

II. Implémentation de CDate

1. Représentation des dates

Il s’agit de décrire dans le détail comment obtenir les services ci-dessus. Mais avant cela, il faut définir comment
une date CDate est représentée.
Ici une date CDate sera représentée par un triplet de trois entiers correspondant respectivement aux jour (_jour),
mois(_mois) et année(_annee) de la date.

2. Implémentation des services

Le fichier CDate.cpp contiendra à présent les codes des traitements déclarés dans la définition de la classe Date
du fichier CDate.h.
Il est d'usage :
• que les traitements simples (quelques instructions) soient en ligne;
• que tout traitement ne devant pas modifier les objets soient des fonctions membres constantes.
a) Implémentation du constructeur avec initialisation
Pour le coder ce constructeur, il faut :
• récupérer la date système si les arguments par défaut sont utilisés (a,m,j=0). Pour cela, on utilisera les
fonctions time() et localtime() déclarées dans time.h héritée de C (voir annexe).
• disposer de fonctions globales (c'est-à-dire statiques) pour vérifier la validité du triplet j, m, a, tester si a est
bissextile, déterminer le nombre de jours maximum dans m.
b) Implémentation des autres services
Pour l’implémentation des autres services, se conformer aux spécifications.
III. Travail à faire
1. Quelles sont les notions de C++ nécessaires à la résolution du problème ?
2. Déclarer et définir la classe CDate.
3. Ecrire un programme simple de test des différents services offerts par la classe CDate.
3
 Deuxième partie : Conception et définition de classes pour la gestion
d’une entreprise
L’objectif de cette partie est de proposer un ensemble de classes permettant la gestion du personnel (salaires,
congés) d’une entreprise.
I. Dans un premier temps, on note que qu’un employé de l’entreprise est caractérisé par : son numéro matricule,
fixé une fois pour toute à l'embauche(string), son nom(string), son prénom(string), sa
fonction(string), son statut (fonctionnaire ou auxiliaire)(enum statut), son adresse(string), sa date de
naissance(CDate), sa date d’embauche(CDate) et son salaire de base(double).
Chaque employé fonctionnaire cotise : 6% de son salaire de base pour la retraite ; 2,75% de son salaire de base
pour la protection sociale si son salaire de base est plus petit que le plafond fixé par l’organisme de gestion de la
protection sociale, dans le cas contraire il cotise pour 2,75% du même plafond. L’auxiliaire ne cotise pas pour la
retraite, par contre il cotise pour la protection sociale au taux de 5% de son salaire de base si ce dernier est inférieur
ou égal au plafond sinon il cotise pour 6,7% du plafond augmenté de 1,5% de la différence entre le salaire de base
et le plafond.
Le salaire de chaque employé est calculé en tenant compte des heures supplémentaires effectuées par l’employé :
le taux horaire est de 2% du salaire de base ; au-delà de 100 heures le taux est majoré de 2,5%.
Les employés sont actuellement décrits par la classe CEmploye.
La classe doit fournir, entre autre, les services suivants:
A. Déclarer et initialiser les employés. Proposer des constructeurs permettant de faire les déclarations et
initialisations qui vous paraissent pertinentes.
B. Savoir si un employé est auxiliaire : bool estAuxiliaire()const .
C. Calculer le salaire d’un employé en tenant compte de son nombre d’heures supplémentaires : double
CalculerSalaire(int nbHeureSupp=0)const.
D. Augmenter le salaire (salaire de base) d'un pourcentage donné, généralement égal à 5% : void
augmenter(float pourcentage=.05).
E. Déterminer, pour un employé, la date de départ à la retraite en fonction de l’âge de la retraite CDate
DateRetraite()const.
F. Voir si un employé doit prendre sa retraite à une année donnée : bool estAnneeRetraite(int
annee)const.
G. Afficher les propriétés pertinentes d’un employé : void Afficher()const
H. Déterminer le nombre de jours de congé d'un employé. le calcul des jours de congés payés s’effectue de la
manière suivante : si une personne est entrée dans l’entreprise depuis moins d’un an, elle a droit à deux jours
de congés par mois de présence (au minimum 1 mois), sinon à 28 jours au moins. Si cette personne est un
cadre et si elle est âgée d’au moins 35 ans et si son ancienneté est supérieure à 3 ans, il lui est accordé 2jours
supplémentaires. Si elle est cadre et si elle est âgée d’au moins 45 ans et si son ancienneté est supérieure à 5
ans, il lui est accordé 4 jours supplémentaires, en plus des 2 accordés pour plus de 35 ans. int
nbJoursDeConge (bool cadre = false) const.
I. Prévoir tous les accesseurs nécessaires
Travail à faire
1. Quelles sont les notions de C++ nécessaires ici à la résolution du problème ?
2. Déclarer (Cemploye.h) et définir (Cemploye.cpp) la classe CEmploye spécifiée ci-dessus.
3. Déclarer dans le fichier utils.h et définir dans le fichier utils.cpp, les fonctions suivantes :
A. InsererEmploye permettant d’ajouter un employé à un tableau d'employés.
B. RechercherEmploye permettant de rechercher dans un tableau d'employés un employé à partir de son
nom.
C. SupprimerEmploye permettant la suppression, d'un tableau d'employés, d’un employé à partir de son
nom.
D. ListeRetraites affichant la liste des employés d'un tableau d'employés devant prendre leurs retraites
courant l'année en cours.
E. MasseSalariale qui donne la masse salariale mensuelle des employés d'un tableau d'employé.
F. CalculerSalaireEmpl qui liste tous les employés avec leurs salaires du mois et la masse salariale
4
 mensuelle du personnel.
G. fonctionnaires qui affiche les fonctionnaires d'un tableau d'employés avec leur proportion par rapport à
l’ensemble des employés.
H. conges affichant chaque employé avec le nombre de ses jours de congés
NB : Pour chaque fonction, on choisira soigneusement ses paramètres et leurs modes de passage ainsi
que son type de retour.
Les listes des employés pourraient être représentées par le type vector
4. Ecrire un programme en C++ itérant sur le menu suivant :

0. Quitter
1. Ajout d’un employé
2. Recherche d’un employé
3. Suppression d’un employé
4. Liste du personnel
5. Liste des retraités….
6. Masse salariale mensuelle
7. Mise en congés

Votre choix

II. En fait le salaire de base d’un employé dépend de sa fonction. On distingue :

▪ Les commerciaux ayant chacun un chiffre d’affaires, _CA(double), et tous la même valeur des
constantes _BASE(double) et _PART(double). Le salaire de base est alors donné par la formule suivante :
BASE +_CA *_PART.
▪ Les techniciens ayant chacun le nombre d’unités produites, _nb_unité_produite(int), et tous la
même valeur des constantes _BASE(double), _PART(double) et _GAIN_UNITE(double). Le salaire de
base est alors donné par la formule suivante: _BASE + _nb_unité_produite * _PART*
_GAIN_UNITE.
▪ Les manutentionnaires ayant chacun le nombre d’heures faites _nb_heures(int) et tous la même
valeur de la constante _BASE_SALAIRE_HORAIRE(double). Le salaire de base est donné par la
formule suivante : _BASE_SALAIRE_HORAIRE*_nb_heures.
Travail à faire
1. Quelles sont les notions de C++ nécessaires ici à la résolution du problème ?
2. Modifier la déclaration de la classe CEmploye en prenant en compte ces nouveaux éléments.
3. Quelles sont les fonctions qui doivent être déclarées en tant que fonctions virtuelles dans la classe CEmploye?
4. Quelles sont les fonctions qui doivent être déclarées en tant que fonctions virtuelles pures dans la classe
CEmploye ? La classe CEmploye est-elle une classe abstraite ?
5. Implémenter les classes CEmploye, CCommercial, CTechnicien, CManutentionnaire.
6. Ecrire un programme en C++ itérant sur le menu suivant :
0. Quitter
1. Ajout d’un employé
2. Recherche d’un employé
3. Suppression d’un employé
4. Liste du personnel(en affichant, pour chaque employé, le détail lié à sa fonction)
5. Liste des retraités….
6. Masse salariale mensuelle
7. Mise en congés
Votre choix

Troisième partie : Représentation d’une entreprise

Une entreprise est caractérisée par son nom, son adresse, son personnel c'est-à-dire la liste de ses employés
(Utiliser la classe vector<T> de STL).
Travail à faire
1. Implémenter la classe CEntreprise, représentant les entreprises.
5
 2. Proposer un programme de gestion de l’entreprise « IT2Entreprise ».

Quatrième partie : Développement d’interfaces graphiques avec Qt

Travail à faire
Proposer une interface pour les principales fonctions du programme de gestion de l’entreprise. Par exemple, une
interface permettant de la mise à jour des employés d’une entreprise :
a. Ajout d’un employé (commercial, technicien ou manutentionnaire)
b. Modification d’un employé
c. Suppression d’un employé
d. Recherche d’un employé
e. Affichage de la liste des employés dans un grille
f. Affichage de l’effectif du personnel de l’entreprise
etc.
Permettre le stockage des employés dans une base de données

6
 ANNEXE
Gestion du temps en C
La bibliothèque C propose au programmeur plusieurs fonctions et structures de données permettant la gestion du
temps. Ces fonctions et structures de données sont déclarées dans le fichier d’entête time.h.
I. Récupération de la date et heure système (time)
Prototype
time_t time(time_t *t);
Description
La fonction time donne le nombre de secondes écoulées depuis le 1er janvier 1970 à 0 heure GMT. Si le
pointeur t est différent de NULL, time place cette valeur à cette adresse. Time_t définit les valeurs
utilisées par les fonctions de gestion de temps; en fait time_t est un alias de unsigned long.
Valeur retournée
Le temps écoulé en secondes depuis le 1er janvier 1970 à 0 heure GMT.
II. Conversion de la date et l'heure en une chaîne (ctime)
Prototype
char *ctime(const time_t *t);
Description
La fonction ctime retourne sous la forme d'une chaîne de caractères la date *t d'une manière formatée et
plus explicite : "NNN MMM jj hh:mm:ss AAAA\n\0"
avec :
NNN Nom du jour (Mon, Tue, Wed, etc...)
MMM Nom du mois (Jan, Feb, Mar, etc...)
jj Numéro du jour (1, 2, ..., 31)
hh Heure (1, 2, ..., 24)
mm Minutes (1, ..., 59)
ss Secondes (1, ..., 59)
AAAA Année (1970...)
Valeur retournée
Cette fonction renvoie un pointeur sur une chaîne de caractères contenant la date et l'heure.
II. Conversion d'une date et heure sous format du calendrier (localtime)
Prototype
struct tm *localtime(const time_t *t);
Description
Cette fonction convertit la valeur reçue en une structure de type struct tm contenant les composants
temporels et applique des corrections de fuseau horaire et d'heure d'été ("daylight saving time").
Valeur retournée
localtime retourne un pointeur sur une structure de type struct tm contenant les différents composants
temporels.
La structure struct tm
Structure définissant des subdivisions du temps :
struct tm {
int tm_sec; /* Secondes */
int tm_min; /* Minutes */
int tm_hour; /* Heures (0 - 23) */
int tm_mday; /* Quantième du mois (1 - 31) */
int tm_mon; /* Mois (0 - 11) */
int tm_year; /* An (= année calendaire - 1900) */
int tm_wday; /* Jour de semaine (0 – 6 avec Dimanche = 0) */
int tm_yday; /* Jour dans l'année (0 - 365) */
int tm_isdst; /* heure d'été (1 : oui, 0 : non) */
};

7
IV. Conversion d'une date et heure au standard GMT (gmtime)
Prototype
struct tm *gmtime(const time_t *t);
Description
gmtime convertit directement vers l'heure GMT (Greenwich Mean Time), contrairement à localtime qui
applique des corrections de fuseau horaire et d'heure d'été.
Valeur retournée
gmtime retourne un pointeur sur une structure de type struct tm contenant les différents composants
temporels.
V. Conversion de la date et l'heure au format de calendrier en une chaîne
(asctime)
Prototype
char *asctime(const struct tm *tblock);
Description
asctime convertit le contenu de la structure *tblock en une chaîne de 26 caractères au format suivant
: "NNN MMM jj hh:mm:ss AAAA\n\0"
Valeur retournée
Cette fonction renvoie un pointeur sur une chaîne de caractères contenant la date et l'heure.
VI. Différence de deux dates (difftime)
Prototype
double difftime(time_t time2, time_t time1);
Description
La fonction difftime calcule le temps écoulé en secondes entre time2 et time1.
Valeur retournée
Un nombre de type double représentant la différence en secondes.
VII. Conversion du temps au format du calendrier (mktime)
Prototype
time_t mktime(struct tm *t);
Description
La fonction mktime convertit la date et l'heure contenues dans la structure *t en valeurs au format
retourné par la fonction time.
Valeur retournée
Une valeur de type time_t si le temps t a pu être converti sinon mktime retourne la valeur -1.