1 laboratorio di calcolo II AA 2003/04 quarta settimana a cura di Domizia Orestano Dipartimento di...
-
Upload
savina-di-carlo -
Category
Documents
-
view
213 -
download
1
Transcript of 1 laboratorio di calcolo II AA 2003/04 quarta settimana a cura di Domizia Orestano Dipartimento di...
1
laboratorio di calcolo IIAA 2003/04
quarta settimana
a cura di
Domizia Orestano
Dipartimento di FisicaStanza 159 - tel. (06 5517) 7281
www.fis.uniroma3.it/[email protected]
UNIVERSITA’ DEGLI STUDI ROMA TRE
DIPARTIMENTO DI FISICA “E. AMALDI”
2
Scopo di questa lezione:
• Imparare a creare nuove classi ereditando da classi già esistenti.
• Capire come l'ereditarietà favorisca il riutilizzo del codice esistente.
• Capire le nozioni di classe base e di classe derivata.
3
Classi base e classi derivate
Figura
2D 3D
Cerchio Poligono Sfera Cubo Tetraedro
Quadrato Triangolo
4
Sintassi
class classeDerivata : elencoClassi {
dichiarazione della classe
};
dove l'elencoClassi e' una lista identificatori di classi base separati da virgole, ciascuno preceduto da una parola chiave che specifica il tipo di accesso.
5
Esempi
class Figura { }; // questa e' una classe base
class 2D : public Figura { }; // 2D eredita da Figura
class Cerchio : public 2D { }; // Cerchio eredita da 2D
6
Altro esempio: personale di un’azienda
Precario Dipendente
Segretaria Manager
Segr_Temp Direttore
Consulente
7
L'ereditarieta' in C++:
• Estensione delle caratteristiche di una classe: la classe derivata è un caso particolare della classe base con alcuni dettagli in più– la figura 2D e' un caso particolare di Figura
– il Cerchio e' una figura 2D
• Adesione ad un modello: la classe base definisce le caratteristiche minimali che devono avere tutte le classi derivate– Se Figura ha un metodo che si chiama disegna tutte le
classi che ereditano da Figura avranno un metodo disegna
8
• L’ereditarieta’ permette di ri-utilizzare il codice e quindi di rendere piu’ “economica” la gestione di programmi complessi
• Codici anche complessi sono piu’ comprensibili e meglio organizzati
• Le relazioni tra concetti appaiono nel codice come relazioni di ereditarieta’
9
Implementazione
• Si identificano classi che appaiono in relazione
• Le classi “in relazione” si organizzano gerarchicamente
• Tra classi organizzate gerearchicamente si identificano
• nuovi attributi
• nuovi metodi
• vecchi metodi che devono essere ri-definiti
10
Figura
char *nome
void disegna( )
2D
char *nome char *colore double superficie void disegna( ) void trasla( ) void ruota( ) double area( )
11
Protezioni
L'accesso ai membri di una classe può essere di tre tipi
• private // dati e metodi inacessibili dall'esterno
• public // dati e metodi accessibili a tutti
• protected // public per le classi derivate, private per gli altri
Analogamente la classe derivata può ereditare dalle classe base in tre modi
• private• public• protected
12
Esempio
class B {public:
int x;protected:
int w;private:
int z;};
13
Derivazione pubblica
• Ogni membro public della classe base è public nella classe derivata
• Ogni membro protected della classe base è protected nella classe derivata
• Ogni membro private della classe base è private per la classe derivata ed è visibile solo dalla classe base
Ovvero le protezioni dei membri della classe base rimangono inalterate nella classe derivata
class D : public B {
// dichiarazione dei membri di D;
};
14
Derivazione protetta
• Ogni membro public della classe base è protected nella classe derivata
• Ogni membro protected della classe base è protected nella classe derivata
• Ogni membro private della classe base è private nella classe derivata ed è visibile solo dalla classe base
class D : protected B {
// dichiarazione dei membri di D;
};
15
Derivazione privata
• Ogni membro public della classe base è private nella classe derivata
• Ogni membro protected della classe base è private nella classe derivata
• Ogni membro private della classe base è private nella classe derivata ed è visibile solo dalla classe base
class D : private B {
// dichiarazione dei membri di D;
};
16
PrivatiPrivatiPrivati private
PrivatiProtettiProtetti protected
PrivatiProtettiPubblici public
Attributi e Metodi Privati
Attributi e Metodi Protetti
Attributi e Metodi Pubblici
Tipo di Ereditarieta’
Riassumendo...
17
Costruttori e Distruttori
• Quando si crea un oggetto di una classe derivata viene prima chiamato il costruttore della classe base e poi quello della classe derivata
• Quando si distrugge un oggetto di una classe derivata viene prima chiamato il distruttore della classe derivata e poi quello della classe base
• È come se la classe base fosse un contenitore per la classe derivata: prima si crea il contenitore, poi il contenuto, prima si cancella il contenuto e poi il contenitore.
18
Creazione di un oggetto base
19
Creazione di un oggetto base
20
Creazione di un oggetto derivato
21
Creazione di un oggetto derivato
22
Cancellazione di un oggetto derivato
23
Cancellazione di un oggetto derivato
24
Cancellazione di un oggetto base
25
Cancellazione di un oggetto base
26
Conversione di tipo tra classi derivate e classi base
• Se la classe D eredita da B e abbiamo le seguenti dichiarazioni:
D d;
B b;• Possiamo convertire un oggetto di tipo D in un
oggetto di tipo B con l'istruzione
b=d; // NB perdiamo informazione• Ma non possiamo fare il contrario
d=b; // NO!!!!!
27
Overloading e Polimorfismo
• Abbiamo già visto accennato che in C e C++ è possibile dare lo stesso nome a più funzioni (o metodi) che vengono distinte dal compilatore grazie alle differenze nella lista dei parametri (overloading)
void stampa( );void stampa( char * commento);
• Ma quando una classe eredita da un'altra ha la possibilità di ridefinire uno o più metodi della classe base (con la stessa lista di parametri!). Questa proprietà si chiama polimorfismo.
28
Ereditarietà Gli oggetti complessi possono essere costruiti a partire da oggetti più
semplici. Gli oggetti complessi derivano tutto o parte del loro
comportamento dagli oggetti a partire dai quali sono stati generati.
Polimorfismo Oggetti simili possono essere trattati, in alcuni casi, come se fossero dello
stesso tipo, senza la necessità di implementare trattamenti specifici per
distinguere tra le varie tipologie.
Overloading dei metodi e degli operatoriMetodi della stessa classe con lo stesso nome possono essere distinti in base al numero e alla tipologia degli argomenti. Gli operatori possono essere ri-definiti per applicarli ai membri di una classe o per definire operazioni tra membri di classi diverse
29
Polimorfismo e compilazione
Una funzione polimorfa può essere applicata ad oggetti appartenenti a classi diverse:Cerchio.disegna( );
Sfera.disegna( );
3D.disegna( );
Talvolta non è possibile per il linker decidere quale metodo selezionare tra i vari metodi disegna a lui noti, perchè non gli è possibile capire la classe di appartenenza di ogni oggetto…
30
binding
• Binding: collegamento tra la chiamata ad una funzione de la sua definizione
• Compile-time, static o early binding: il collegamento viene effettuato dal linker
• Run-time, dynamic o late binding: il collegamento viene effettuato durante l'esecuzione del codice, al momento della chiamata
• Una virtual function è una particolare dichiarazione C++ che consente il late binding
31
1. Per indicare al compilatore che deve cercare il metodo nella classe piu’ “bassa” nella catena gerarchica si usa la parola virtual
2. virtual va utilizzato nella classe piu’ “alta” nella catena gerarchica delle classi che devono utilizzare il polimorfismo (ma e’ bene ripeterlo anche nelle classi “figlie”)
3. Se un metodo e’ dichiarato virtual
• Il compilatore ricerca un metodo nella classepiu’ bassa nella catena di ereditarieta’(esempio: calcolaPosizione(fx,fy,dt) )
• Se non lo trova esegue il metodo nella classepiu’ alta (esempio: X() Vx() )
4. Sintassi virtual void calcolaPosizione (float fx, float fy, float dt);
Metodi virtuali
32
#ifndef CORPOCELESTE_H#define CORPOCELESTE_Hclass CorpoCeleste { protected:
char *Nome;double m;double x;double y;double vx;double vy;
public: CorpoCeleste() ; CorpoCeleste (const char *nomeCorpo, float mass, float xpos, float ypos, float vxi, float vyi); ~CorpoCeleste() ; virtual void calcolaPosizione (float fx, float fy, float t); void stampaPosizione(); void stampaVelocita() ; const char *nome() ; double M() ; double X() ; double Y() ; double Vx() ; double Vy() ;};#endif
CorpoCeleste.h con modifiche per ereditarietà
33
Sonda
tCount (num. reale) tStart (num. reale) owner (CorpoCeleste *) svx (num. reale) svy (num. reale) started (char)
Sonda(…)
~Sonda()
CalcolaPosizione(forza, dt)
CorpoCeleste
Nome (stringa)m (num. reale)x (num. reale)y (num. reale)vx (num. reale)vy (num. reale)
CorpoCeleste( …. )~Corpoceleste()CalcolaPosizione(forza, dt)StampaVelocita’()StampaPosizione() M() X() Y() Vx() Vy()
La classe Sonda
34
35
#include "CorpoCeleste.h"
class Sonda: public CorpoCeleste {
protected: float tCount; float tStart; CorpoCeleste *owner; float svx; float svy; char started;
public:
Sonda(const char *name, float mass, float starttime, CorpoCeleste *startFrom, float vxi, float vyi);
~Sonda() { } ;
void calcolaPosizione (float fx, float fy, float t);
};
Sonda.h
36
#include "Sonda.h"
#include <iostream.h>
Sonda::Sonda(const char *name, float mass,
float starttime, CorpoCeleste startFrom, float vxi, float vyi) : CorpoCeleste(name, mass, 0., 0., 0., 0.) {
tStart = starttime ;
tCount = 0 ;
owner = startFrom ;
svx = vxi ; svy = vyi ;
started = 0 ;
x = owner->X() ; y = owner->Y() ;
vx = owner->Vx() ;
vy = owner->Vy() ;
}
Sonda.cc
prima parte
37
void Sonda::calcolaPosizione (float fx, float fy, float t) {
if (tCount<tStart) {
x = owner->X() ;
y = owner->Y() ;
vx = owner->Vx() ;
vy = owner->Vy() ;
} else {
if (!started) {
cerr << "Sonda in partenza...\n” ;
vx += svx ;
vy += svy ;
started = 1 ;
}
CorpoCeleste::calcolaPosizione(fx,fy,t);
}
tCount += t ;
}
Sonda.cc
seconda parte
38
1. Voglio rappresentare un Oggetto
CorpoCeleste terra(…..) ;
2. Voglio rappresentare piu’ oggetti
CorpoCeleste terra(…..) ; CorpoCeleste sole(…..) ;
3. Voglio rappresentare tanti oggetti (solo se di dimensione costante!)
CorpoCeleste pianeti[10] ; pianeti[0] = …. ; pianeti[1] = … ;
4. Voglio rappresentare tanti oggetti legati tra loro da ereditarieta’devo usare un vettore di puntatori
CorpoCeleste * pianeti[10] ; pianeti[0] = new CorpoCeleste(…); pianeti[1] = new Sonda(…);
Ereditarietà e puntatori
39Sputnik
Voyager
terra
sole
p[0] p[1] p[2] p[3]
CorpoCeleste
Sonda
CorpoCeleste *
40
#include “SistemaSolare.h”
#include “Sonda.h”
int main() {
SistemaSolare ss(3) ; // definisci un SistemaSolare
// definisci due pianeti
CorpoCeleste sole(“Il Sole”, 1.98e30, 0., 0., 0., 0.) ;
CorpoCeleste terra(“La Terra”, 5.98e24, 1.52e11, 0., 0., 29476.35) ;
// definisci una sonda
Sonda voyager(“Voyager II”, 110000., &terra, 100., 38000., -10800.) ;
// aggiungi i pianeti e la sonda al sistema solare
ss.aggiungiPianeta(&sole) ;
ss.aggiungiPianeta(&terra) ;
ss.aggiungiPianeta(&voyager) ;
// fai evolvere il sistema per 365 giorni
ss.evolvi(86400*365, 86400) ;
return 0 ;
}
simula.cc
41
Quando viene invocato il Costruttore di una Classe che eredita da altre, il compilatore invoca automaticamente i Costruttori di tutte le Classi nella catena di ereditarieta’, inziando dal costruttore “piu’ in alto” nella catena gerarchica
Quando viene invocato il Distruttore di una Classe che eredita da altre, il compilatore invoca automaticamente i Costruttori di tutte le Classi nella catena di ereditarieta’, inziando dal costruttore “piu’ in basso” nella catena gerarchica
Se ad un oggetto si accede tramite il suo puntatore, istanziato come puntatore di una delle classi madre, e’ necessario che il distruttore sia definito virtual, in modo che il compilatore inizi ad invocare il distruttore piu’ in basso nella catena di ereditarieta’, risalendo poi tutta la catena gerarchica.
Distruttori virtuali
42
Autoveicolo
Autovettura
Auto_Fiat
Autocarro
Punto Panda
Distruttori virtuali: esempio
43
Creazione di oggetti
Distruzione di oggetti (accedendo ad un oggetto tramite puntatore ad Autovettura)
Distruzione di oggetti(accedendo ad un oggetto tramite puntatore + virtual)
Creo un Autoveicolo
Creo una Autovettura
Creo una Auto_Fiat
Creo una Punto
Distruggo una Autovettura
Distruggo un Autoveicolo
Distruggo una Punto
Distruggo una Auto_Fiat
Distruggo una Autovettura
Distruggo un Autoveicolo
44
1. Se un metodo e’ dichiarato virtual, la classe che eredita (la classe piu’ bassa nella catena gerarchica) puo’ ridefinire il metodo, che e’ comunque implementato nella classe da cui si eredita
2. Se un metodo e’ dichiarato pure virtual(virtual …. = 0 ; ) tutte le classi che ereditano devono fornire il metodo, che non e’ implementato nella classe da cui si eredita
3. Sintassi
virtual double Area() = 0 ;
4. Una classe con almeno un metodo pure virtual si chiama classe astratta
5. Attenzione! Gli oggetti di una classe astratta non possono essere istanziati
Metodi pure virtual e classi astratte
45
classi astratte
Attenzione! Gli oggetti di una classe astratta non possono essere istanziati
Ma allora a che serve tale classe?
E’ un “modello” che definisce l’interfaccia comune di tutti gli oggetti appartenenti ad una certa categoria costringendo tutte le classi che da essa ereditano ad implementare certi metodi (cf. pag.7)