Ereditarietà

ChatGPT In C++, l'ereditarietà consente a una classe di acquisire le proprietà (attributi e metodi) di un'altra classe.
Gli attributi e i metodi di una classe base possono essere ereditati da una classe derivata, che consente di riusare il codice e creare una gerarchia di classi.
Gli attributi protected sono accessibili alle classi derivate, mentre quelli private non lo sono.

Ecco un esempio che illustra l'ereditarietà, l'utilizzo degli attributi protected e private con classi che rappresentano veicoli a motore, automobili e automobili utilitarie:

#include <iostream>
#include <string>

// Classe base (super classe) - VeicoloAMotore
class VeicoloAMotore {
protected:
    std::string tipoMotore;  // Attributo protetto

public:
    // Costruttore
    VeicoloAMotore(const std::string& tipo) : tipoMotore(tipo) {}

    // Metodo pubblico
    void AccendiMotore() {
        std::cout << "Motore acceso." << std::endl;
    }
};

// Classe derivata - Automobile
class Automobile : public VeicoloAMotore {
private:
    int numeroPorte;  // Attributo privato

public:
    // Costruttore
    Automobile(const std::string& tipo, int porte) : VeicoloAMotore(tipo), numeroPorte(porte) {}

    // Metodo pubblico
    void Guida() {
        std::cout << "Guida l'automobile." << std::endl;
    }

    // Metodo pubblico che accede all'attributo protetto tipoMotore
    void StampaTipoMotore() {
        std::cout << "Tipo motore: " <<tipoMotore << std::endl;
    }
};

// Classe derivata - AutomobileUtilitaria
class AutomobileUtilitaria : public Automobile {
public:
    // Costruttore
    AutomobileUtilitaria(const std::string& tipo, int porte) : Automobile(tipo, porte) {}

    // Metodo pubblico
    void TrasportaMerci() {
        std::cout << "Trasporta merci." <<std::endl;
    }
};

int main() {
    // Creazione di un'istanza di AutomobileUtilitaria
    AutomobileUtilitaria utilitaria("Diesel", 4);

    // Utilizzo dei metodi delle classi derivate
    utilitaria.AccendiMotore();
    utilitaria.Guida();
    utilitaria.TrasportaMerci();

    // Utilizzo del metodo che accede all'attributo protetto tipoMotore
    utilitaria.StampaTipoMotore();

    return 0;
}

In questo esempio:
- `VeicoloAMotore` è una classe base con un attributo protetto `tipoMotore`.
- `Automobile` è una classe derivata da `VeicoloAMotore` che eredita l'attributo protetto e ha un attributo privato `numeroPorte`.
- `AutomobileUtilitaria` è una classe derivata da `Automobile` che eredita gli attributi e i metodi di entrambe le classi superiori.

L'attributo `tipoMotore` è marcato come `protected`, quindi può essere accessibile direttamente da `Automobile` e da `AutomobileUtilitaria`.
L'attributo `numeroPorte` è marcato come `private`, quindi può essere accessibile solo all'interno della classe `Automobile`.

Oggetto

Come creare un oggetto e inizializzarne i parametri nel main.

int main() {
    // Creazione di un'istanza di AutomobileUtilitaria con inizializzazione dei parametri
    AutomobileUtilitaria utilitaria("Benzina", 5);

    // Utilizzo dei metodi delle classi derivate
    utilitaria.AccendiMotore();
    utilitaria.Guida();
    utilitaria.TrasportaMerci();

    // Utilizzo del metodo che accede all'attributo protetto tipoMotore
    utilitaria.StampaTipoMotore();

    return 0;
}

In questo esempio, l'oggetto `utilitaria` è un'istanza della classe `AutomobileUtilitaria`, e durante la sua creazione, vengono passati i parametri necessari al costruttore della classe. Nel caso specifico, viene passato "Benzina" come tipo di motore e 5 come numero di porte.
Questi parametri vengono poi utilizzati per inizializzare gli attributi della classe durante la creazione dell'oggetto.