Revisão - Hierarquia de funcionários

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 55 de 104.

Desafio

Fácil

Vamos criar um sistema completo de hierarquia de funcionários que reúne todos os conceitos de herança que você aprendeu neste capítulo. Você criará uma estrutura de empresa com diferentes tipos de funcionários que compartilham atributos comuns, mas têm comportamentos especializados.

Você organizará seu código em quatro arquivos:

Employee.h: Defina a classe base Employee da qual todos os tipos de funcionários herdarão. Todo funcionário tem um nome, um ID e um salário-base. Inclua:
- Membros protegidos para nome (std::string), id (int) e baseSalary (double)
- Um construtor que inicializa os três valores
- Um método virtual displayInfo() que imprime: Employee: <name> (ID: <id>)
- Um método virtual calculateSalary() que retorna o salário-base
- Um destrutor virtual
Manager.h: Defina uma classe Manager que herda publicamente de Employee. Gerentes recebem um bônus com base no tamanho de sua equipe:
- Um membro privado int teamSize
- Um construtor que recebe nome, id, salário-base e tamanho da equipe: encadeie-o adequadamente ao construtor da classe base
- Substitua displayInfo() para imprimir: Manager: <name> (ID: <id>) - Team of <teamSize>
- Substitua calculateSalary() para retornar o salário-base mais 500 para cada membro da equipe
Developer.h: Defina uma classe Developer que herda publicamente de Employee. Desenvolvedores têm uma linguagem de especialidade e recebem um bônus por habilidade:
- Um membro privado std::string language
- Um construtor que recebe nome, id, salário-base e linguagem de programação
- Substitua displayInfo() para imprimir: Developer: <name> (ID: <id>) - <language>
- Substitua calculateSalary() para retornar o salário-base mais um bônus de habilidade de 1000
main.cpp: Leia seis entradas (cada uma em uma linha separada):
1. Nome do gerente
2. ID do gerente
3. Salário-base do gerente
4. Nome do desenvolvedor
5. ID do desenvolvedor
6. Salário-base do desenvolvedor
Crie um Manager com tamanho de equipe 4 e um Developer especializado em "C++". Armazene ponteiros para ambos em um array de ponteiros Employee*. Percorra o array para chamar displayInfo() e imprimir o salário calculado de cada funcionário neste formato:
```
<displayInfo output>
Salary: $<calculated salary>
```
Imprima uma linha em branco entre os funcionários. Depois de exibir todos os funcionários, exclua corretamente os objetos alocados dinamicamente.

Por exemplo, com as entradas Sarah, 101, 5000, Mike, 102 e 4500:

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

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

Este desafio demonstra o polimorfismo em ação: chamar métodos virtuais por meio de ponteiros da classe base invoca as implementações corretas das classes derivadas. Lembre-se de usar a palavra-chave override e incluir um destrutor virtual em sua classe base para uma limpeza adequada.

Experimente você mesmo

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

using namespace std;

int main() {
    // Ler entradas do Manager
    string managerName;
    int managerId;
    double managerSalary;
    
    getline(cin, managerName);
    cin >> managerId;
    cin >> managerSalary;
    cin.ignore();
    
    // Ler entradas do Developer
    string developerName;
    int developerId;
    double developerSalary;
    
    getline(cin, developerName);
    cin >> developerId;
    cin >> developerSalary;
    
    // TODO: Crie um Manager com tamanho de equipe 4
    // TODO: Crie um Developer que se especializa em "C++"
    
    // TODO: Crie um array de ponteiros Employee* para armazenar ambos os employees
    
    // TODO: Percorra o array e para cada employee:
    //   - Chame displayInfo()
    //   - Imprima: Salary: $<salário calculado>
    //   - Imprima uma linha em branco entre os employees (não após o último)
    
    // TODO: Delete os objetos alocados dinamicamente
    
    return 0;
}