Esercizi Ereditarietà Multipla C++

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;
}