C++ Academy · Lezione

Ereditarietà singola e multipla

Modelli le relazioni is-a con l'ereditarietà singola e gestisca le insidie dell'ereditarietà multipla

Ereditarietà singola e multipla è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Che cos'è l'ereditarietà?

L'ereditarietà consente a una classe di riutilizzare ed estendere un'altra classe: la prima è la classe derivata, la seconda è la classe base. Modella le relazioni «è-un».

class Animal {
public:
    void breathe() { std::cout << "breathing\n"; }
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!\n"; }
};

Ereditarietà pubblica

Utilizzi public per modellare una relazione «è-un»: un Dog è un Animal. I membri mantengono il proprio livello di accesso nella classe derivata.

Ereditarietà protetta e privata

L'ereditarietà protected e private modella la relazione «è implementato in termini di», ma viene usata raramente. In questi casi, preferisca la composizione.

Accedere ai membri della classe base

La classe derivata può utilizzare direttamente qualsiasi membro pubblico o protetto della classe base.

Dog d;
d.breathe();    // inherited from Animal
d.bark();        // own member

Ordine dei costruttori

I costruttori della classe base vengono eseguiti prima di quelli della classe derivata. Utilizzi la lista di inizializzazione dei membri per passare argomenti alla classe base.

class Pet : public Animal {
    std::string name_;
public:
    Pet(std::string n) : Animal(), name_(std::move(n)) {}
};

Ordine dei distruttori

I distruttori vengono eseguiti in ordine inverso: prima quello della classe derivata, poi quello della classe base. Renda i distruttori della classe base virtual se elimina gli oggetti tramite un puntatore alla classe base.

Ereditarietà multipla

C++ consente a una classe di ereditare da più di una classe base. La utilizzi con moderazione: complica la progettazione.

class Printable { public: virtual void print() = 0; };
class Serializable { public: virtual std::string serialize() = 0; };

class Document : public Printable, public Serializable {
    // implements both interfaces
};

Il problema del diamante

Se due classi base condividono una classe base comune, la classe derivata finisce per contenere due copie di quella classe base. Risolva il problema con l'ereditarietà virtuale.

class A {};
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};   // D has ONE A, not two

Costo dell'ereditarietà virtuale

Le classi base virtuali aggiungono un sovraccarico: un puntatore aggiuntivo per oggetto e un'indirezione aggiuntiva per ogni accesso a un membro della classe base. La eviti quando possibile.

Composizione o ereditarietà

Spesso la composizione «ha-un» è più semplice dell'ereditarietà «è-un». Un Car ha un Engine: non faccia ereditare Car da Engine.

class Engine { /* ... */ };
class Car {
    Engine engine_;       // composition
};

Ereditarietà dell'interfaccia o dell'implementazione

Due usi comuni:

Interfaccia: derivi da una classe base con funzioni virtuali pure per rispettare un contratto
Implementazione: derivi per riutilizzare codice (CRTP, mixin)

Quando utilizzare l'ereditarietà

Utilizzi l'ereditarietà quando:

esiste una reale relazione «è-un»
ha bisogno del polimorfismo a runtime tramite funzioni virtuali
la classe base è progettata per essere usata come base

Verifica rapida

Quale tecnica impedisce di avere due copie di una classe base comune quando si utilizza l'ereditarietà multipla?

Riepilogo

L'ereditarietà modella le relazioni «è-un» tramite l'ereditarietà pubblica. L'ereditarietà multipla è consentita, ma il problema del diamante richiede l'ereditarietà virtuale. Preferisca la composizione per le relazioni «ha-un» e il riutilizzo del codice.

Domande Frequenti

La lezione «Ereditarietà singola e multipla» è gratuita?

Sì — il testo completo di «Ereditarietà singola e multipla» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Ereditarietà singola e multipla»?

Modelli le relazioni is-a con l'ereditarietà singola e gestisca le insidie dell'ereditarietà multipla Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Ereditarietà singola e multipla»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy