1 laboratorio di calcolo II AA 2003/04 quarta settimana a cura di Domizia Orestano Dipartimento di Fisica Stanza tel. ( ) 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 unazienda

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 Lereditarieta 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 Privati private PrivatiProtetti 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 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 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 classe piu bassa nella catena di ereditarieta (esempio: calcolaPosizione(fx,fy,dt) ) Se non lo trova esegue il metodo nella classe piu alta (esempio: X() Vx() ) 4.Sintassi virtual void calcolaPosizione (float fx, float fy, float dt); Metodi virtuali

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 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 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

39

40 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 PuntoPanda 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 linterfaccia 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) pag.7