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/~orestanoorestano@fis.uniroma3.it

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)