|
Reimpiego di codice con l'ereditarieta`
Il meccanismo dell'ereditarieta` e` per molti aspetti simile a quello della
composizione quando si vuole modellare una relazione di tipo Is-a.
L'idea e` quella di dire al compilatore che una nuova classe (detta classe
derivata) e` ottenuta da una preesistente (detta classe base)
"copiando" il codice di quest'ultima nella classe derivata eventualmente sostituendone
una parte qualora una qualche funzione membro venisse ridefinita:
class Person {
public:
Person();
~Person();
void PrintData();
/* ... */
private:
char* Name;
unsigned int Age;
/* ... */
};
class Student : Person { // Dichiara che la classe
public: // Student eredita da Person
Student();
~Student();
/* ... */
private:
unsigned int IdCode;
/* ... */
};
In pratica quanto fatto fin'ora e` esattamente la stessa cosa che abbiamo fatto
con la composizione (vedi esempio), la differenza e` che non abbiamo inserito
nella classe Student alcuna istanza della classe Person
ma abbiamo detto al compilatore di inserire tutte le dichiarazioni e le definizioni
fatte nella classe Person nello scope della classe Student,
a tal proposito si dice che la classe derivata eredita i membri della classe
base.
Ci sono due sostanziali differenze tra l'ereditarieta` e la composizione:
- Con la composizione ciascuna istanza della classe contenitore possiede al
proprio interno una istanza della classe componente; con l'ereditarieta` le
istanze della classe derivata formalmente non contengono nessuna istanza della
classe base, le definizioni fatte nella classe base vengono "quasi" immerse
tra quelle della classe derivata senza alcuno strato intermedio (il "quasi"
e` giustificato dal punto 2);
- Un oggetto composto puo` accedere solo ai membri pubblici della componente,
l'ereditarieta` permette invece di accedere direttamente anche ai membri protetti
della classe base (quelli privati rimangono inaccessibili alla classe derivata).
|