Riepilogo - Gerarchia dei dipendenti

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 55 di 104.

Sfida

Facile

Costruiamo un sistema completo di gerarchia dei dipendenti che riunisce tutti i concetti di ereditarietà che hai imparato in questo capitolo. Creerai la struttura di un'azienda con diversi tipi di dipendenti che condividono attributi comuni, ma hanno comportamenti specifici.

Organizzerai il codice in quattro file:

Employee.h: Definisci la classe base Employee da cui erediteranno tutti i tipi di dipendenti. Ogni dipendente ha un nome, un ID e uno stipendio base. Includi:
- Membri protetti per il nome (std::string), l'ID (int) e baseSalary (double)
- Un costruttore che inizializza tutti e tre i valori
- Un metodo virtuale displayInfo() che stampa: Employee: <name> (ID: <id>)
- Un metodo virtuale calculateSalary() che restituisce lo stipendio base
- Un distruttore virtuale
Manager.h: Definisci una classe Manager che eredita pubblicamente da Employee. I manager ricevono un bonus basato sulle dimensioni della squadra:
- Un membro privato int teamSize
- Un costruttore che accetta nome, ID, stipendio base e dimensioni della squadra: richiama correttamente il costruttore della classe base
- Sovrascrivi displayInfo() affinché stampi: Manager: <name> (ID: <id>) - Team of <teamSize>
- Sovrascrivi calculateSalary() affinché restituisca lo stipendio base più 500 per ogni membro della squadra
Developer.h: Definisci una classe Developer che eredita pubblicamente da Employee. Gli sviluppatori hanno una lingua di specializzazione e ricevono un bonus per le competenze:
- Un membro privato std::string language
- Un costruttore che accetta nome, ID, stipendio base e linguaggio di programmazione
- Sovrascrivi displayInfo() affinché stampi: Developer: <name> (ID: <id>) - <language>
- Sovrascrivi calculateSalary() affinché restituisca lo stipendio base più un bonus di 1000 per le competenze
main.cpp: Leggi sei input (ciascuno su una riga separata):
1. Nome del manager
2. ID del manager
3. Stipendio base del manager
4. Nome dello sviluppatore
5. ID dello sviluppatore
6. Stipendio base dello sviluppatore
Crea un Manager con una squadra di 4 persone e un Developer specializzato in "C++". Memorizza i puntatori a entrambi in un array di puntatori Employee*. Scorri l'array per chiamare displayInfo() e stampare lo stipendio calcolato di ciascun dipendente in questo formato:
```
<displayInfo output>
Salary: $<calculated salary>
```
Stampa una riga vuota tra i dipendenti. Dopo aver visualizzato tutti i dipendenti, elimina correttamente gli oggetti allocati dinamicamente.

Ad esempio, con gli input Sarah, 101, 5000, Mike, 102 e 4500:

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

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

Questa sfida dimostra il polimorfismo in azione: chiamare metodi virtuali tramite puntatori alla classe base invoca le implementazioni corrette delle classi derivate. Ricorda di usare la parola chiave override e di includere un distruttore virtuale nella classe base per una corretta pulizia.

Provalo tu

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

using namespace std;

int main() {
    // Read Manager inputs
    string managerName;
    int managerId;
    double managerSalary;
    
    getline(cin, managerName);
    cin >> managerId;
    cin >> managerSalary;
    cin.ignore();
    
    // Read Developer inputs
    string developerName;
    int developerId;
    double developerSalary;
    
    getline(cin, developerName);
    cin >> developerId;
    cin >> developerSalary;
    
    // TODO: Create a Manager with team size 4
    // TODO: Create a Developer who specializes in "C++"
    
    // TODO: Create an array of Employee* pointers to store both employees
    
    // TODO: Loop through the array and for each employee:
    //   - Call displayInfo()
    //   - Print: Salary: $<calculated salary>
    //   - Print a blank line between employees (not after the last one)
    
    // TODO: Delete the dynamically allocated objects
    
    return 0;
}