Video: Nuovo Corso C++11 ITA 143: ereditarietà - classi astratte 2024
C ++ supporta late binding , che è quando risolve una chiamata al metodo basata sul tempo di esecuzione tipo (o tipo dinamico) dell'oggetto di destinazione anziché il tipo dichiarato (o il tipo statico). Questo è dimostrato nel seguente frammento di codice C ++:
# include using namespace std; Class Oven {public: virtual void cook () {cout << "cottura con forno" << endl;}}; classe MicrowaveOven: public Oven {public: virtual void cook () {cout << "cucina con forno a microonde" << endl;}}; vuoto preparazione pasti (forno e forno) {forno. cook ();}
Nella funzione prepareMeal (), la chiamata al forno. cook () può passare al forno: cook () o MicrowaveOven:: cook () a seconda del tempo di esecuzione (il tipo "effettivo") dell'oggetto del forno passato.
La parola chiave virtuale è fondamentale qui. Senza di esso, il metodo cook () verrà associato in anticipo, in base al tipo in fase di compilazione, e invocherà Oven:: cook () ogni volta. Una volta dichiarato virtuale nella classe Oven, si presume che il metodo sia virtuale in ogni sottoclasse, ma non fa male ripetere la dichiarazione in modo che i lettori capiscano.
Il seguente semplice programma dimostra in pratica questo principio:
int main () {Forno forno; prepareMeal (forno); MicrowaveOven mo; prepareMeal (mo); return 0;}
In questo programma, la chiamata a cook () genera due uscite diverse a seconda del tipo di forno:
Cottura con un forno Cottura con un forno a microonde
Non è sempre il caso, che un metodo nella classe base può essere definito. Considera più attentamente il caso del forno. Esistono diversi tipi di forni - forni tradizionali, forni a convezione e forni a microonde - ma si potrebbe sostenere che non esiste un forno effettivo che non appartiene a una di queste sottoclassi. Potresti essere in grado di dire in che modo i vari tipi di forni eseguono l'operazione di cottura, ovvero ciò che un ConventionalOven:: cook () e un MicrowaveOven:: cook () dovrebbe fare può essere definito. Probabilmente non è possibile definire quali azioni deve eseguire Forno: cook ().
Non puoi semplicemente lasciare Forno: cook () non dichiarato in un linguaggio fortemente tipizzato come C ++. Tuttavia, è possibile dichiarare un metodo, ma lasciarlo non implementato se non esiste alcuna implementazione. Uno usa la seguente sintassi curiosa per farlo:
class Oven {public: virtual void cook () = 0;};
Questo codice dichiara un metodo Forno: cook () che è legato in ritardo ma non implementa il metodo. In realtà, va oltre dicendo che il metodo non sarà implementato. In C ++, si dice che tale metodo sia puro virtuale . I programmatori C ++ usano anche il termine preferito in molti altri linguaggi di computer fortemente tipizzati: abstract .La classe del forno si dice che sia astratta.
Un riassunto rappresenta una proprietà che conosci che la classe possiede ma non sa come implementarla in modo inequivocabile nella classe corrente.
Una classe è astratta se contiene uno o più metodi virtuali puri. Il significato di questo è che non è possibile creare un'istanza di una classe astratta. Quindi non è più permesso quanto segue:
int main () {Forno forno; prepareMeal (forno); return 0;}
La ragione di questo è abbastanza semplice: se hai creato un oggetto di Class Oven e poi hai provato a invocare il forno. cook (), cosa dovrebbe fare il compilatore?
A un livello più filosofico, va bene dire che esiste un termine comune chiamato Forno che descrive forni e forni a microonde convenzionali e forni a convezione. Questo termine forno è un concetto usuale perché lega le somiglianze in tutte queste sottoclassi. Ma non esiste un'istanza di un forno che non sia una delle sottoclassi di Forno.
Una sottoclasse di una classe astratta è essa stessa astratta fino a quando tutti i metodi virtuali puri sono stati sostituiti da versioni non astratte (ovvero concrete ). Quindi la classe MicrowaveOven nel precedente frammento di codice non è astratta - anche se Oven fosse astratto - perché sovrascrive cook () con la sua versione concreta.
Si noti che non vi è nulla di sbagliato nella funzione prepareMeal () definita come segue:
void prepareMeal (Forno e forno) {forno. cook ();}
Anche se l'argomento è dichiarato essere un forno, può essere invocato solo con alcune sottoclassi di forno, come MicrowaveOven o ConventionalOven, per cui cook () è definito.
