Récapitulatif : hiérarchie des employés

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 55 sur 104.

Défi

Facile

Construisons un système complet de hiérarchie d'employés qui rassemble tous les concepts d'héritage que tu as appris dans ce chapitre. Tu vas créer une structure d'entreprise avec différents types d'employés qui partagent des attributs communs, mais qui possèdent des comportements spécialisés.

Tu vas organiser ton code sur quatre fichiers :

Employee.h : Définir la classe Employee de base dont tous les types d'employés hériteront. Chaque employé possède un nom, un ID et un salaire de base. Inclure :
- Des membres protégés pour le nom (std::string), l'id (int) et baseSalary (double)
- Un constructeur qui initialise les trois valeurs
- Une méthode virtuelle displayInfo() qui affiche : Employee: <name> (ID: <id>)
- Une méthode virtuelle calculateSalary() qui renvoie le salaire de base
- Un destructeur virtuel
Manager.h : Définir une classe Manager qui hérite publiquement de Employee. Les managers reçoivent un bonus basé sur la taille de leur équipe :
- Un membre privé int teamSize
- Un constructeur qui accepte le nom, l'id, le salaire de base et la taille de l'équipe : chaîner correctement vers le constructeur de la classe de base
- Redéfinir displayInfo() pour afficher : Manager: <name> (ID: <id>) - Team of <teamSize>
- Redéfinir calculateSalary() pour renvoyer le salaire de base plus 500 pour chaque membre de l'équipe
Developer.h : Définir une classe Developer qui hérite publiquement de Employee. Les développeurs ont une langue de spécialité et reçoivent un bonus de compétence :
- Un membre privé std::string language
- Un constructeur qui accepte le nom, l'id, le salaire de base et le langage de programmation
- Redéfinir displayInfo() pour afficher : Developer: <name> (ID: <id>) - <language>
- Redéfinir calculateSalary() pour renvoyer le salaire de base plus un bonus de compétence de 1000
main.cpp : Lire six entrées (chacune sur une ligne distincte) :
1. Nom du Manager
2. ID du Manager
3. Salaire de base du Manager
4. Nom du Developer
5. ID du Developer
6. Salaire de base du Developer
Créer un Manager avec une taille d'équipe de 4 et un Developer spécialisé en "C++". Stocker les pointeurs vers les deux dans un tableau de pointeurs Employee*. Parcourir le tableau pour appeler displayInfo() et afficher le salaire calculé pour chaque employé dans ce format :
```
<displayInfo output>
Salary: $<calculated salary>
```
Afficher une ligne vide entre les employés. Après avoir affiché tous les employés, supprimer correctement les objets alloués dynamiquement.

Par exemple, avec les entrées Sarah, 101, 5000, Mike, 102 et 4500 :

Manager: Sarah (ID: 101) - Team of 4
Salary: $7000

Developer: Mike (ID: 102) - C++
Salary: $5500

Ce défi montre le polymorphisme en action : appeler des méthodes virtuelles via des pointeurs vers la classe de base invoque les implémentations correctes des classes dérivées. N'oublie pas d'utiliser le mot-clé override et d'inclure un destructeur virtuel dans ta classe de base pour un nettoyage correct.

Essayez vous-même

#include <iostream>
#include <string>
#include "Employee.h"
#include "Manager.h"
#include "Developer.h"

using namespace std;

int main() {
    // Lire les entrées du Manager
    string managerName;
    int managerId;
    double managerSalary;
    
    getline(cin, managerName);
    cin >> managerId;
    cin >> managerSalary;
    cin.ignore();
    
    // Lire les entrées du Developer
    string developerName;
    int developerId;
    double developerSalary;
    
    getline(cin, developerName);
    cin >> developerId;
    cin >> developerSalary;
    
    // TODO: Créer un Manager avec une taille d'équipe de 4
    // TODO: Créer un Developer qui se spécialise en "C++"
    
    // TODO: Créer un tableau de pointeurs Employee* pour stocker les deux employés
    
    // TODO: Parcourir le tableau et pour chaque employé :
    //   - Appeler displayInfo()
    //   - Afficher : Salary: $<salaire calculé>
    //   - Afficher une ligne vide entre les employés (pas après le dernier)
    
    // TODO: Supprimer les objets alloués dynamiquement
    
    return 0;
}