Esercizi Ereditarietà Multipla C++
- Esercizio 1: Ereditarietà multipla semplice
- Esercizio 2: Ereditarietà multipla con conflitto di nomi
- Esercizio 3: Ereditarietà multipla con costruttori
- Esercizio 4: Ereditarietà multipla con distruttori
- Esercizio 5: Ereditarietà multipla con membri dati
- Esercizio 6: Ereditarietà multipla con metodi virtuali
- Esercizio 7: Ereditarietà multipla con interfacce
- Esercizio 8: Ereditarietà multipla con ereditarietà virtuale
- Esercizio 9: Ereditarietà multipla con membri protetti
- Esercizio 10: Ereditarietà multipla con costruttori e parametri
Ecco degli esercizi semplici con soluzione per praticare l’ereditarietà multipla in C++.
Esercizio 1: Ereditarietà multipla semplice
Creare due classi base e una classe derivata che eredita da entrambe.
#include <iostream>
class Base1 {public: void funzioneBase1() { std::cout << "Funzione della Base1" << std::endl; }};
class Base2 {public: void funzioneBase2() { std::cout << "Funzione della Base2" << std::endl; }};
class Derivata : public Base1, public Base2 {};
int main() { Derivata d; d.funzioneBase1(); d.funzioneBase2(); return 0;}
Esercizio 2: Ereditarietà multipla con conflitto di nomi
Gestire il conflitto di nomi tra due classi base usando l'ereditarietà multipla.
#include <iostream>
class Base1 {public: void funzione() { std::cout << "Funzione della Base1" << std::endl; }};
class Base2 {public: void funzione() { std::cout << "Funzione della Base2" << std::endl; }};
class Derivata : public Base1, public Base2 {public: void funzioneDerivata() { Base1::funzione(); Base2::funzione(); }};
int main() { Derivata d; d.funzioneDerivata(); return 0;}
Esercizio 3: Ereditarietà multipla con costruttori
Gestire i costruttori nelle classi base e derivata usando l'ereditarietà multipla.
#include <iostream>
class Base1 {public: Base1() { std::cout << "Costruttore della Base1" << std::endl; }};
class Base2 {public: Base2() { std::cout << "Costruttore della Base2" << std::endl; }};
class Derivata : public Base1, public Base2 {public: Derivata() { std::cout << "Costruttore della Derivata" << std::endl; }};
int main() { Derivata d; return 0;}
Esercizio 4: Ereditarietà multipla con distruttori
Gestire i distruttori nelle classi base e derivata usando l'ereditarietà multipla.
#include <iostream>
class Base1 {public: ~Base1() { std::cout << "Distruttore della Base1" << std::endl; }};
class Base2 {public: ~Base2() { std::cout << "Distruttore della Base2" << std::endl; }};
class Derivata : public Base1, public Base2 {public: ~Derivata() { std::cout << "Distruttore della Derivata" << std::endl; }};
int main() { Derivata d; return 0;}
Esercizio 5: Ereditarietà multipla con membri dati
Creare classi base con membri dati e una classe derivata che accede a questi membri.
#include <iostream>
class Base1 {public: int x; Base1() : x(10) {}};
class Base2 {public: int y; Base2() : y(20) {}};
class Derivata : public Base1, public Base2 {public: void stampa() { std::cout << "x = " << x << ", y = " << y << std::endl; }};
int main() { Derivata d; d.stampa(); return 0;}
Esercizio 6: Ereditarietà multipla con metodi virtuali
Usare metodi virtuali nelle classi base e sovrascriverli nella classe derivata.
#include <iostream>
class Base1 {public: virtual void funzione() { std::cout << "Funzione della Base1" << std::endl; }};
class Base2 {public: virtual void funzione() { std::cout << "Funzione della Base2" << std::endl; }};
class Derivata : public Base1, public Base2 {public: void funzione() override { std::cout << "Funzione della Derivata" << std::endl; }};
int main() { Derivata d; d.funzione(); return 0;}
Esercizio 7: Ereditarietà multipla con interfacce
Creare due interfacce e una classe derivata che implementa entrambe.
#include <iostream>
class Interfaccia1 {public: virtual void funzione1() = 0;};
class Interfaccia2 {public: virtual void funzione2() = 0;};
class Derivata : public Interfaccia1, public Interfaccia2 {public: void funzione1() override { std::cout << "Implementazione di funzione1" << std::endl; } void funzione2() override { std::cout << "Implementazione di funzione2" << std::endl; }};
int main() { Derivata d; d.funzione1(); d.funzione2(); return 0;}
Esercizio 8: Ereditarietà multipla con ereditarietà virtuale
Usare l'ereditarietà virtuale per evitare il problema del diamante.
#include <iostream>
class Base {public: void funzione() { std::cout << "Funzione della Base" << std::endl; }};
class Derivata1 : virtual public Base {};
class Derivata2 : virtual public Base {};
class DerivataFinale : public Derivata1, public Derivata2 {};
int main() { DerivataFinale df; df.funzione(); return 0;}
Esercizio 9: Ereditarietà multipla con membri protetti
Usare membri protetti nelle classi base e accedervi nella classe derivata.
#include <iostream>
class Base1 {protected: int x;public: Base1() : x(10) {}};
class Base2 {protected: int y;public: Base2() : y(20) {}};
class Derivata : public Base1, public Base2 {public: void stampa() { std::cout << "x = " << x << ", y = " << y << std::endl; }};
int main() { Derivata d; d.stampa(); return 0;}
Esercizio 10: Ereditarietà multipla con costruttori e parametri
Creare classi base con costruttori parametrizzati e una classe derivata che li inizializza.
#include <iostream>
class Base1 {protected: int x;public: Base1(int a) : x(a) { std::cout << "Costruttore della Base1" << std::endl; }};
class Base2 {protected: int y;public:
Base2(int b) : y(b) { std::cout << "Costruttore della Base2" << std::endl; }};
class Derivata : public Base1, public Base2 {public: Derivata(int a, int b) : Base1(a), Base2(b) { std::cout << "Costruttore della Derivata" << std::endl; } void stampa() { std::cout << "x = " << x << ", y = " << y << std::endl; }};
int main() { Derivata d(10, 20); d.stampa(); return 0;}