dynamic_cast febbraio Introduzione al C++ e alla programmazione ad oggetti

Transcript

1 dynamic_cast dynamic_cast opera una conversione, se è possibile, fra due tipi. Il puntatore ritornato NON è nullo soltanto se il tipo dell oggetto su cui si opera è quello che ci si aspetta class Base.... // base implementation class Derived: public Base.... void new_method() ; // non e definito in Base! void func(base *ptr) // ptr e un obbetto dell classe Base ptr->new_method(); // Errore!!! Derived *p = dynamic_cast<derived *> (ptr) if (p!=0) p->new_method(); febbraio

2 Ereditarietà (4) Una classe derivata estende la classe base e ne eredita tutti i metodi e gli attributi Track.h class class Track Track LorentzVector LorentzVector momentum() momentum() return return p_; p_; protected: protected: LorentzVector LorentzVector p_; p_; DchTrack è una Track che ha degli attributi in più (hits_) e nuovi metodi (DchHit* hit(int n), int hits()) DchTrack.h #include #include Track.h Track.h class class DchTrack DchTrack : : public public Track Track int int hits() hits() return return hits_->size(); hits_->size(); DchHit* DchHit* hit(int hit(int n) n) return return hits_[n]; hits_[n]; protected: protected: list<dchhit> list<dchhit> hits_; hits_; febbraio

3 Esempio: shape Tutti gli oggetti nella finestra hanno comportamenti comuni che possono essere considerati in astratto: disegna sposta ingrandisc etc febbraio

4 Cerchi e quadrati Quadrato Cerchio febbraio

5 Circle.h Punto e virgola! Cerchio class Circle Circle(Point2d center, double radius); ~Circle(); void moveat(const Point2d & p); void moveby(const Point2d & p); void scale(double s); void rotate(double phi); void draw() const; void cancel() const; private: Point2d center_; double radius_; Nome della classe Costruttore Distruttore Point2d: : classe che rappresenta un punto in 2 dimensioni. Interfaccia Pubblica Metodi: : operazioni sugli oggetti Dati privati (Attributi,, membri) febbraio

6 Circle.cc #include Circle.h Cerchio (2) void Circle::draw() const const int numberofpoints = 100; float x[numberofpoints], y[numberofpoints]; float phi = 0, deltaphi = 2*M_PI/100; for ( int i = 0; i < numberofpoints; ++i ) x[i] = center_.x() + radius_ * cos( phi ); y[i] = center_.y() + radius_ * sin( phi ); phi += dphi; polyline_draw(x, y, numberofpoints, color_, FILL); void Circle::moveAt( const Point2d& p ) cancel(); center_ = p; draw(); void Circle::scale( double s ) cancel(); radius_ *= s; draw(); Main.cc #include Circle.h int main() Circle c( Point2d(10, 10), 5 ); c.draw(); c.moveat(point2d(20, 30)); Circle::Circle( Point2d c, double r ) : center_( c ), radius_( r ) draw(); return 0; Circle::~Circle() cancel(); febbraio

7 Square.h Quadrato class Square Square(const Point2d&, const Point2d&, Color color = TRASPARENT); ~Square(); void moveat( const Point2d& p ); void moveby( const Point2d& p ); void changecolor( Color color ); void scale( double s ); void rotate( double phi ); void draw() const; void cancel() const; Square.cc #include Square.h void Square::draw() const float x[4], y[4]; Vector2d delta( centertouppercorner_ ); for ( int i = 0; i < 4; i++ ) Point2d corner = center_ + delta; x[i] = corner.x(); y[i] = corner.y(); delta.rotate( M_PI_2 ); polyline_draw(x, y, 4, color_, FILL); private: Point2d center_; Vector2d centertouppercorner_; Color color_; void Square::rotate( double phi ) cancel(); centertouppercorner_.rotate( phi ); draw(); centertouppercorner_ lowecorner uppercorner Square::Square(const Point2d& lowercorner, const Point2d& uppercorner, Color color) : center_( median(lowercorner, uppercorner) ), centertouppercorner_( uppercorner - center_ ), color_( color ) draw(); void Square::scale( double s ) cancel(); centertouppercorner_ *= s; draw(); febbraio

8 Main.cc #include Circle.h #include Square.h Codice Applicativo (Client) int main() Circle c1( Point2d(2.,3.), 4.23 ); Square r1( Point2d(2.,1.), Point2d(4.,3.) ); Circle * circles[ 10 ]; for ( int i = 0; i < 10; ++i ) circles[ i ] = new Circle( Point2d(i,i), 2. ); Costruisce un vettore di puntatori a cerchi, crea oggetti in memoria e salva i loro puntatori nel vettore. for ( int i = 0; i < 10; ++i ) circles[ i ]->draw(); return 0; Come gestire cerchi e quadrati insieme? Itera sul vettore e invoca draw() per ogni elemento febbraio

9 Polimorfismo Tutte le Shapes hanno la stessa interfaccia: draw, pick, move, fillcolor......, ma ogni sottotipo diverso può avere la usa personale implementazione febbraio

10 Interfaccia astratta Shape.h class Shape Shape() virtual ~Shape() Main.cc #include Circle.h virtual void moveat(const Point2d& where) = 0; #include Square.h virtual void changecolor(color newcolor) = 0; virtual void scale(double s) = 0; int main() virtual void rotate(double phi) = 0; virtual void draw() const = 0; Shape * shapes[ 20 ]; virtual void cancel() const = 0; int index = 0; for ( int i = 0; i < 10; i++ ) Shape * s; Interfaccia di metodi s = new Circle( Point2d(i, i), 2.) ); shapes[ index ++ ] = s; puramente virtuali s = new Square( Point2d(i, i), Point2d(i+1, i+2)) ); Square.h shapes[ index ++ ] = s; #include Shape.h class Square : public Shape //. Il resto tutto uguale a prima for ( int i = 0; i < 20; i++ ) shapes[ i ]->draw(); return 0; febbraio

11 CenteredShape.h Class CenteredShape: public Shape CenteredShape(Point2d c, Color color = TRASPARENT) : center_(c), color_(color) /*draw();*/ ~Circle() /*cancel();*/ void moveat( const Point2d& ); void moveby( const Vector2d& ); void changecolor( Color ); virtual void scale( double ) = 0; virtual void rotate( double ) = 0; virtual void draw() const = 0; virtual void cancel() const = 0; protected: Point2d center_; Color color_; Ereditarietà e riuso del codice Square.h #include CenteredShape.hh Non si possono chiamare metodi virtuali in costruttori e distruttori (troppo presto, troppo tardi) class Square : public CenteredShape Square( Point2d lowercorner, Point2d uppercorner, Color col = TRASPARENT) : CenteredShape( median(lowercorner, uppercorner), col), touc_(uppercorner - center_) draw(); ~Square() cancel(); virtual void scale( double s ) cancel(); centertouppercorner_ *= s; draw(); virtual void rotate( double phi ); virtual void draw() const; virtual void cancel() const; private: Vector2d touc_; febbraio

12 Rectangle.h Attenzione alle generalizzazioni... class Rectangle Rectangle(double x0, double y0, double lx, double ly) : lx_(lx), ly_(ly), x0_(x0), y0_(y0) void scalex(double s); void scaley(double s); protected: double x0_, y0_; double lx_, ly_; Square.h Attenzione: scegliere le relazioni di ereditarietà può essere non banale. Un quadrato è un rettangolo? class Square : public Rectangle Square(double x0, double y0, double l) : Rectangle(x0, y0, l, l) Avere lx_ lx_ e ly_ ly_ è ridondante per per Square Cosa Cosa succede se se si si invoca scalex o scaley? febbraio

13 Ereditarietà multipla Una classe può ereditare da più classi DrawableObj.h class DrawableObj virtual void draw() = 0; Shape.h class Shape virtual void scale(double s) = 0; virtual void moveat( Vector2d& ) = 0; DrawableShape.h class DrawableShape : public DrawableObj, public Shape virtual void draw(); virtual void scale(double s); virtual void moveat( Vector2d& ); febbraio

14 Strategie di sviluppo di un progetto Requisiti: cosa l utente vuole Analisi: la visione dell informatico dei requisiti Disegno: l aspetto del sistema software Produzione: codifica Testing: debugging e verifica dei requisiti Mantenimento: installazione del prodotto e controllo del funzionamento per il resto della sua vita febbraio

15 Modello a cascata Requisiti Analisi Disegno Produzione Testing febbraio

16 Modello evoluzionario Requisiti Testing Analisi Produzione Disegno febbraio

17 Confronto fra i modelli di A cascata Processo lineare (si torna al passo precedente solo in caso di problemi) Confinamento delle attività in ogni fase Facile da gestire (gestione delle scadenze) Difficile da modificare Prodotto utilizzabile solo alla fine del processo sviluppo Evoluzionario Processo ciclico (brevi processi completi) Attività distribuite su più fasi Difficile da gestire Facile da modificare e integrare Prototipo utilizzabile fin dal primo ciclo febbraio

18 Requisiti Definizione delle richieste da parte dell utente del programma (o di una sua parte) sul sistema Si parla di programmazione per contratto perchè l utente richiede solamente la definizione del servizio richiesto NON la metodologia seguita per fornirglielo è possibile delegare parte del lavoro richiesto ad altri il sistema è indipendente da chi è il suo utente INCAPSULAMENTO! febbraio

19 Analisi Comprensione e razionalizzazione delle richieste dell utente Costruzione di un modello astrazione (semplificazione delle relazioni) rilevanza (identificazione degli oggetti chiave) Da non trascurare: analisi delle soluzioni esistenti. Può far risparmiare molto tempo!!! febbraio

20 Disegno Definizione di oggetti e classi Definizione degli stati e dell implementazione Definizione delle interfacce Definizione delle relazioni febbraio

21 Disegno (2) Dopo ogni ciclo bisogna analizzare i rischi, la stabilità del disegno e la complessità delle classi Se una classe è troppo complessa conviene dividerla Ad ogni ciclo il numero di modifiche deve diminuire Architetture troppo complesse devono essere modularizzate febbraio

22 Codifica C è poco da dire Non sopravvalutate questa fase: Suddivisione del tempo per il primo ciclo Testing 20% Analisi 30% Codifica 15% Disegno 35% febbraio

23 Testing Debugging: è ovvio il codice non deve dare errori. Use cases: specificano il comportamento del sistema in una regione. Scenarios: sono esempi concreti di use cases. Per definizione se tutti gli scenari sono soddisfatti correttamente il test è positivo febbraio