laboratorio di calcolo II AA 2003/04 quarta settimana

1. UNIVERSITA’ DEGLI STUDI ROMA TRE DIPARTIMENTO DI FISICA “E. AMALDI” laboratorio di calcolo IIAA 2003/04quarta settimana a cura di Domizia Orestano Dipartimento di Fisica Stanza 159 - tel. (06 5517) 7281 www.fis.uniroma3.it/~orestano orestano@fis.uniroma3.it

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

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. 2D Figura char *nome char *colore double superficie void disegna( ) void trasla( ) void ruota( ) double area( ) char *nome void disegna( )

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 class D : public B { // dichiarazione dei membri di D; }; • Ogni membro public della classe base è publicnella 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

14. Derivazione protetta class D : protected B { // dichiarazione dei membri di D; }; • 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

15. Derivazione privata class D : private B { // dichiarazione dei membri di D; }; • Ogni membro public della classe base è privatenella classe derivata • Ogni membro protecteddella classe base è private nella classe derivata • Ogni membro private della classe base è private nella classe derivata ed è visibile solo dalla classe base

16. Tipo di Ereditarieta’ Attributi e Metodi Pubblici Attributi e Metodi Protetti Attributi e Metodi Privati public Pubblici Protetti Privati protected Protetti Protetti Privati private Privati Privati Privati 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 lorocomportamento 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 operatori Metodi 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. Metodi virtuali • Per indicare al compilatore che deve cercare il metodo nella classe piu’ “bassa” nella catena gerarchica si usa la parola virtual • 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”) • 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() ) • Sintassi • virtual void calcolaPosizione • (float fx, float fy, float dt);

32. #ifndef CORPOCELESTE_H #define CORPOCELESTE_H class 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. La classe Sonda CorpoCeleste Sonda Nome (stringa) m (num. reale) x (num. reale) y (num. reale) vx (num. reale) vy (num. reale) tCount (num. reale) tStart (num. reale) owner (CorpoCeleste *) svx (num. reale) svy (num. reale) started (char) CorpoCeleste( …. ) ~Corpoceleste() CalcolaPosizione(forza, dt) StampaVelocita’() StampaPosizione() M() X() Y() Vx() Vy() Sonda(…) ~Sonda() CalcolaPosizione(forza, dt)

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,CorpoCelestestartFrom,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. Ereditarietà e puntatori • Voglio rappresentare un Oggetto • CorpoCeleste terra(…..) ; • Voglio rappresentare piu’ oggetti • CorpoCeleste terra(…..) ; • CorpoCeleste sole(…..) ; • Voglio rappresentare tanti oggetti (solo se di dimensione costante!) • CorpoCeleste pianeti[10] ; • pianeti[0] = …. ; • pianeti[1] = … ; • 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(…);

40. simula.cc

41. Distruttori virtuali 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.

42. Autoveicolo Autovettura Autocarro Auto_Fiat Punto Panda Distruttori virtuali: esempio

43. Creazione di oggetti Creo un Autoveicolo Creo una Autovettura Creo una Auto_Fiat Creo una Punto Distruzione di oggetti (accedendo ad un oggetto tramite puntatore ad Autovettura) Distruggo una Autovettura Distruggo un Autoveicolo Distruzione di oggetti (accedendo ad un oggetto tramite puntatore + virtual) Distruggo una Punto Distruggo una Auto_Fiat Distruggo una Autovettura Distruggo un Autoveicolo

44. Metodi pure virtual e classi astratte • 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 • 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 • Sintassivirtual double Area() = 0 ; • Una classe con almeno un metodo pure virtual si chiama classe astratta • Attenzione! Gli oggetti di una classe astratta non possono essere istanziati

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)