Ereditarietà di base

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

L'ereditarietà consente a una classe di acquisire le proprietà e i comportamenti di un'altra classe. La classe da cui si eredita è chiamata classe base (o classe genitore), mentre la classe che eredita è chiamata classe derivata (o classe figlia).

Per creare una classe derivata, usa i due punti seguiti dallo specificatore di accesso e dal nome della classe base:

class Animal {
public:
    std::string name;
    
    void eat() {
        std::cout << name << " is eating" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << name << " says woof!" << std::endl;
    }
};

La classe Dog ora può accedere sia a name sia a eat() di Animal, oltre al proprio metodo bark(). Questa è l’essenza dell’ereditarietà: riutilizzare il codice esistente aggiungendo nuove funzionalità.

Dog myDog;
myDog.name = "Buddy";
myDog.eat();    // Ereditato da Animal
myDog.bark();   // Definito in Dog

La parola chiave public prima di Animal specifica il tipo di ereditarietà. L’ereditarietà pubblica significa che i membri pubblici della classe base rimangono pubblici nella classe derivata. Questa è la forma più comune e rappresenta una relazione «è-un»: un Dog è un Animal.

Sfida

Facile

Costruiamo una semplice gerarchia di veicoli che dimostri l'ereditarietà in azione. Creerai una classe base Vehicle e una classe derivata Motorcycle che la estende con comportamenti specifici.

Organizzerai il codice in tre file:

Vehicle.h: Definisci una classe base Vehicle con:
- Un membro pubblico std::string brand
- Un membro pubblico int year
- Un metodo pubblico displayInfo() che stampa la marca e l'anno del veicolo nel formato: Brand: <brand>, Year: <year>
Motorcycle.h: Definisci una classe Motorcycle che eredita pubblicamente da Vehicle. Questa classe derivata dovrebbe aggiungere:
- Un membro pubblico int engineCC per la cilindrata del motore
- Un metodo pubblico revEngine() che stampa: <brand> goes vroom vroom!
La classe Motorcycle erediterà automaticamente brand, year e displayInfo() da Vehicle.
main.cpp: Leggi tre input (ciascuno su una riga separata):
1. Nome della marca (stringa)
2. Anno (intero)
3. Cilindrata in CC (intero)
Crea un oggetto Motorcycle, imposta i suoi membri ereditati (brand e year) e anche il suo membro engineCC. Poi produci le tre righe di output nell'ordine seguente: prima chiama il metodo ereditato displayInfo(), poi stampa tu la cilindrata con std::cout << "Engine: " << moto.engineCC << "cc" << std::endl; e infine chiama il metodo specifico della motocicletta revEngine(). Questo dimostra l'ereditarietà utilizzando sia il metodo ereditato sia il metodo proprio della classe derivata.

Formato dell'output:
```
Brand: <brand>, Year: <year>
Engine: <engineCC>cc
<brand> goes vroom vroom!
```

Per esempio, con gli input Harley, 2022 e 1200:

Brand: Harley, Year: 2022
Engine: 1200cc
Harley goes vroom vroom!

Non dimenticare di includere le guardie di inclusione nei file header e di usare #include "Vehicle.h" nell'header Motorcycle per accedere alla classe base.

Provalo tu

#include <iostream>
#include <string>
#include "Motorcycle.h"

using namespace std;

int main() {
    string brand;
    int year;
    int engineCC;

    cin >> brand;
    cin >> year;
    cin >> engineCC;

    // TODO: Crea un oggetto Motorcycle
    // TODO: Imposta i membri brand, year ed engineCC dell'oggetto
    // TODO: Chiama displayInfo() per mostrare le informazioni ereditate
    // TODO: Stampa le informazioni sul motore nel formato: Engine: <engineCC>cc
    // TODO: Chiama revEngine() per mostrare il comportamento specifico della motocicletta

    return 0;
}