1

laboratorio di calcolo IIAA 2003/04

quinta 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

sommario

Ripasso degli argomenti trattati la settimana scorsa:ereditarietà, protezioni, polimorfismo e metodi virtuali, distruttori e distruttori virtuali, cosa abbiamo osservato nell’esercitazione

Un altro esempio che illustra nuovamenteereditarietà, polimorfismo e metodi virtuali, distruttori e distruttori virtuali, classi astratte

Overloading Dei metodi e degli operatori, esempi

3

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

4

PrivatiPrivatiPrivati private

PrivatiProtettiProtetti protected

PrivatiProtettiPubblici public

Attributi e Metodi Privati

Attributi e Metodi Protetti

Attributi e Metodi Pubblici

Tipo di Ereditarieta’

ProtezioniAffinché la classe derivata possa accedere agli attributi dellaclasse base, senza violare l’incapsulamento che nasconde gli attributi della classe base al resto del codice, questi devono essere dichiarati protected nella classe base.

I clienti della classe derivata vedono i membri (attributi e metodi) della

classe base con livelli di protezione che dipendono da come si è dichiarata la relazione di ereditarietà:

5

1. In presenza di metodi polimorfi, presenti con lo stesso prototipo in più classi legate da ereditarietà, 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);

ma anche virtual ~CorpoCeleste ( );

Metodi virtuali

6

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

7

Esercitazione della scorsa settimana

Avete definito (.h) ed implementato (.cc) la classe Sonda che eredita da CorpoCeleste. Una Sonda è un CorpoCeleste con alcune caratteristiche in più (viene fatta partire dalla superficie di un CorpoCeleste con una certa velocità iniziale ad un istante fissato) e con una versione modificata del metodo calcolaPosizione.

Per inserire oggetti della nuova classe nella simulazione del sistema solare è statosufficiente instanziarli nel main e dichiararli con aggiungiPianeta alla classe SistemaSolare, non sono state necessarie modifiche a SistemaSolare.

8

#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

9

#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

10

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

11

#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., 100., &terra, 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

12

Alcune modifiche sono state invece apportate in CorpoCeleste.h:

• dichiarazione gli attributi protected anziché privatechi se ne fosse scordato ha riscontrato un errore di compilazione quando Sonda cerca di accedere x, y , vx o vy (nel costruttore e in calcolaPosizione)

• dichiarazione come virtual del metodo CorpoCeleste::calcolaPosizionealtrimenti, in SistemaSolare::evolvi, l’istruzionepianeti[i]->calcolaPosizione((float)fx, (float)fy, dt);chiamerebbe sempre CorpoCeleste::calcolaPosizione, anche per i puntatori ad oggetti Sonda

• dichiazione come virtual del metodo CorpoCeleste::~CorpoCelesteper far chiamare Sonda ::~Sonda (che a sua volta chiama CorpoCeleste::~CorpoCeleste ) quando si effettui il delete di un puntatore ad un CorpoCeleste che sia anche un Sonda

Chi ne ha avuto il tempo ha anche provato a rendere pure virtual un metodo di CorpoCeleste e dovrebbe avere osservato un problema nella compilazione del main: sole e terra non possono più essere istanziati!

13

#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); virtual ~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à

14

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

15

Supponiamo di avere tre classi (shape, cerchio e quadrato) legate tra loro da una relazione di Ereditarietà.

shape

cerchio quadrato

Un altro esempio

16

#ifndef SHAPE_H#define SHAPE_H

#include <iostream.h>

class shape {

public: shape() {}; ~shape() { cout << " Distruggo una shape " << endl << endl ; };

void print() { cout << " Sono una shape" << endl ; };

};

#endif

shape.h

17

#ifndef CERCHIO_H#define CERCHIO_H

#include <iostream.h>#include ”shape.h"

class cerchio : public shape {

public: cerchio() {}; ~cerchio() { cout << " Distruggo un cerchio " << endl << endl ; };

void print() { cout << " Sono un cerchio " << endl ; };

};

#endif

cerchio.h

18

#ifndef QUADRATO_H#define QUADRATO_H

#include <iostream.h>#include "shape.h"

class quadrato : public shape {

public: quadrato() {}; ~quadrato() { cout << " Distruggo un quadrato " << endl << endl ; };

void print() { cout << " Sono un quadrato " << endl ; };

};

#endif

quadrato.h

19

int main() {

shape s; cerchio c; quadrato q;

cout << endl; s.print(); c.print(); q.print();

shape * v[3]; v[0] = new shape; v[1] = new cerchio; v[2] = new quadrato;

cout << endl; v[0]->print(); v[1]->print(); v[2]->print();

cout << " ================== " << endl ; cout << " Applico delete " << endl ;

cout << “ shape 0 : " << endl; delete v[0]; cout << " shape 1 : " << endl; delete v[1]; cout << " shape 2 : " << endl; delete v[2]; cout << endl; cout << " =================== " << endl; return 0;

};

Sono una shape Sono una shape Sono una shape

Sono una shape Sono un cerchio Sono un quadrato

Senza virtual

20

#ifndef SHAPE_H#define SHAPE_H

#include <iostream.h>

class shape {

public: shape() {}; ~shape() { cout << " Distruggo una shape " << endl << endl ; };

void print() { cout << " Sono una shape" << endl ; };

};

#endif

shape.h

virtual

21

int main() {

shape s; cerchio c; quadrato q;

cout << endl; s.print(); c.print(); q.print();

shape * v[3]; v[0] = new shape; v[1] = new cerchio; v[2] = new quadrato;

cout << endl; v[0]->print(); v[1]->print(); v[2]->print();

cout << " ================== " << endl ; cout << " Applico delete " << endl ;

cout << “ shape 0 : " << endl; delete v[0]; cout << " shape 1 : " << endl; delete v[1]; cout << " shape 2 : " << endl; delete v[2]; cout << endl; cout << " =================== " << endl; return 0;

};

Sono una shape Sono un cerchio Sono un quadrato

Con virtual

Sono una shape Sono un cerchio Sono un quadrato

22

int main() {

shape s; circle c; quadrato q;

cout << endl; s.print(); c.print(); q.print();

shape * v[3]; v[0] = new shape; v[1] = new circle; v[2] = new quadrato;

cout << endl; v[0]->print(); v[1]->print(); v[2]->print();

cout << " ================== " << endl ; cout << " Applico delete " << endl ;

cout << “ shape 0 : " << endl; delete v[0]; cout << " shape 1 : " << endl; delete v[1]; cout << " shape 2 : " << endl; delete v[2]; cout << endl; cout << " =================== " << endl; return 0;};

Senza distruttore virtual

Distruggo un quadrato Distruggo una shape

Distruggo un cerchio Distruggo una shape

Distruggo una shape

========================== Applico delete shape 0 : Distruggo una shape

shape 1 : Distruggo una shape

shape 2 : Distruggo una shape =========================

23

#ifndef SHAPE_H#define SHAPE_H

#include <iostream.h>

class shape {

public: shape() {}; ~shape() { cout << " Distruggo una shape " << endl << endl ; };

void print() { cout << " Sono una shape" << endl ; };

};

#endif

shape.h

virtual

virtual

24

Con distruttore virtualint main() {

shape s; circle c; quadrato q;

cout << endl; s.print(); c.print(); q.print();

shape * v[3]; v[0] = new shape; v[1] = new circle; v[2] = new quadrato;

cout << endl; v[0]->print(); v[1]->print(); v[2]->print();

cout << " ================== " << endl ; cout << " Applico delete " << endl ;

cout << “ shape 0 : " << endl; delete v[0]; cout << " shape 1 : " << endl; delete v[1]; cout << " shape 2 : " << endl; delete v[2]; cout << endl; cout << " =================== " << endl; return 0;};

Distruggo un quadrato Distruggo una shape

Distruggo un cerchio Distruggo una shape

Distruggo una shape

========================== Applico delete shape 0 : Distruggo una shape

shape 1 : Distruggo un cerchio Distruggo una shape

shape 2 : Distruggo un quadrato Distruggo una shape =========================

25

Supponiamo ora di voler aggiungere alle classi geometriche un metodo che determini l’area della figura.

L’area di una figura si calcola in modo diverso a seconda della sua forma. Dovremo quindi fornire una diversa implementazione di

double Area( ) ;per ogni classe.

Che metodo Area( ) mettiamo in shape? Ci mettiamo un metodo pure virtual che fornisce il modello per le classi derivate

virtual double Area( ) = 0 ;

26

#ifndef SHAPE_H#define SHAPE_H

#include <iostream.h>

class shape {

public: shape() {}; virtual ~shape() { cout << " Distruggo una shape " << endl << endl ; };

virtual void print() { cout << " Sono una shape" << endl ; }; virtual double Area()=0;

};

#endif

shape.h

27

Se ora provassimo a compilare il main avremmo degli errori :1. Gli oggetti di tipo cerchio e di tipo quadrato non sono validi

perché non hanno il metodo Area2. Gli oggetti di tipo shape non possono essere istanziati per lo

stessso motivo

Rimosso dal main l’oggetto di tipo shape aggiungiamo il metodo Area nelle classi derivate:

28

#ifndef CERCHIO_H#define CERCHIO_H

#include <iostream.h>#include ”shape.h“#include <math.h>

class cerchio : public shape {

private:

double radius;

public: cerchio(double r):radius(r) {}; ~cerchio() { cout << " Distruggo un cerchio " << endl << endl ; };

void print() { cout << " Sono un cerchio " << endl ; }; double Area() { return M_PI*radius*radius; };

};

#endif

cerchio.h

29

#ifndef QUADRATO_H#define QUADRATO_H

#include <iostream.h>#include "shape.h"

class quadrato : public shape {

private:

double side;

public: quadrato(s):side(s) {}; ~quadrato() { cout << " Distruggo un quadrato " << endl << endl ; };

void print() { cout << " Sono un quadrato " << endl ; }; double Area() { return side*side; };

};

#endif

quadrato.h

30

int main() {

shape * v[2]; v[0] = new circle(1); v[1] = new quadrato(1);

cout << endl; v[0]->print(); cout << v[0]->Area() <<endl; v[1]->print(); cout << v[1]->Area() <<endl;

cout << " ================== " << endl ; cout << " Applico delete " << endl ;

cout << " shape 0 : " << endl; delete v[0]; cout << " shape 1 : " << endl; delete v[1]; cout << endl; cout << " =================== " << endl; return 0;};

31

Due metodi della stessa classe aventi lo stesso nome, possono essere distinti in base:

1. Al numero degli argomenti

CorpoCeleste( )

CorpoCeleste(char * nome, float mass, float x, float y)

2. Al tipo degli argomenti calcolaPosizione(float fx,float dt);

calcolaPosizione(TwoVector f, float dt);

3. [ ovviamente: al tipo e al numero degli argomenti] calcolaPosizione(float fx, float fy, float dt);

calcolaPosizione(TwoVector f, float dt);

Non e’ possibile distinguere tra metodi in base al tipo del metodo (void, int, double, …)

Overloading dei metodi

32

Operatori aritmetici in C++Addizione X+Y

Sottrazione X-Y

Moltiplicazione X*Y

Divisione X/Y

Modulo X%Y

Addizione unaria +X

Sottrazione unaria -X

Preincremento ++X

Postincremento X++

Predecremento --X

Postdecremento X--

bina

riun

ari

NB non c’e’ l’operatore elevazione a potenza, si utilizza un metodo con 2 parametri: double pow(double base,double potenza)

33

Operatori sui bit in C++

Right shift dei bit X >> n

Left shift dei bit X << n

OR X | Y

AND X & Y

XOR X ^ Y

34

Operatori logici in C++

Test di uguaglianza X = = Y

Test di differenza X != Y

Test di ordinamento X < Y

Test di ordinamento X > Y

Test di ordinamento X <= Y

Test di ordinamento X >= Y

AND logico X && Y

OR logico X || Y

NOT logico !X

35

Operatori di assegnazione in C++

Assegnazione X =Y

Assegnazione con somma X +=Y

Assegnazione con sottrazione X -=Y

Assegnazione con moltiplicazione X *=Y

Assegnazione con divisione X /=Y

Assegnazione con modulo X %=Y

Assegnazione con right shift dei bit X >>= n

Assegnazione con left shift dei bit X <<=n

Assegnazione con AND X &= Y

Assegnazione con OR X |= Y

Assegnazione con XOR X ^= Y

36

Overloading degli operatoriConsente di definire un’algebra all’interno della classe.

Tutto ciò che facciamo con un operatore unario potrebbe essere realizzato mediante un metodo membro senza parametri, che si limiti ad agire sull’oggetto in esame (this) o con una funzione esterna alla classe che riceva un unico parametro (una reference all’oggetto).

Tutto ciò che facciamo con un operatore binario potrebbe essere realizzato mediante un metodo membro con un parametro o una funzione esterna a due parametri.

L’uso degli operatori rende il codice più leggibile e consente un’interpretazione più immediata delle operazioni effettuate. E’ importante però non stravolgere il significato convenzionale dei simbili utilizzati: non definite una sottrazione scegliendo + come simbolo !

37

Gli operatori definiti all’interno della classe si chiamano operatori membro.

Gli operatori definiti in questo modo sono un modo naturale (e compatto) di identificare un metodo (della classe) e come tali possono accedere ai membri privati.

Gli operatori membro si applicano ad oggetti di una classe e possono avere come argomento

nessun oggetto (operatori unari)

un oggetto (operatori binari)

a+b

a.operator+(b)

a=b

a.operator=(b)

a=b+c

a.operator=(b.operator+(c))

Operatori membro

38

class Compl { private: double re; double im ;

public:

// costruttori Compl() ; Compl(double a) ; Compl(double a, double b) ; Compl(Compl & c) ; ~Compl() ; //distruttore

//metodi di tipo Setvoid set_Re(double a);

void set_Im(double b);

//metodi di tipo Getdouble const Real() ;double const Imm() ;

//operatori unari Compl & operator- (); //operatori binari

Compl & operator= (Compl const & c);Compl operator+ (Compl const & c);

} ;

Un esempio classico:

la classe dei numeri complessi

39

Compl c1(2,3),c2(1,2),c3; c3 = c1 + c2;// equivalente a c3.operator=(c1.operator+(c2))

double a = 5;c3 = c1 + a;

// Ma non posso scrivere c3 = a + c1

conversioni tra tipiL’operatore

Compl operator+ (Compl const & c);somma all’oggetto this il numero complesso c e ritorna il numero complesso risultante, consentendo operazioni del tipo

Come posso fare per sommare oggetti complessi e oggetti reali tra loro? Prevedo l’opportuno operatore membro

Compl operator+ (doubl const & a);

40

Posso ricorrere ad un operatore non membro a due argomenti

Compl operator+(Compl const & c1, Compl const &c2);

Che viene dichiarato dopo la chiusura della dichiarazione della classe e che non ha accesso ai membri privati della classe (dovrà usare metodi di tipo get).

Posso quindi implementare operatori specifici

Compl operator+(Compl const & c1, double const &a);

Compl operator+(double const & a, Compl const &c2);

O far uso del costruttore Compl(double a) che consente di scrivere

double a = 5;

compl c=a;

Funzioni a due argomenti

41

L’overloading degli operatori << (cout) e >> (cin) avviene con funzioni non membro. Gli operatori

ostream &

operator << (ostream & fstream, const Compl & c);

istream &

operator >> (istream & fstream, const Compl & c);

Sono definiti fuori della definizione della classe

overloading dell’operatore << (cout)overloading dell’operatore >> (cin)

42

Per referenza o per valore?1. Negli argomenti delle funzioni, dei metodi e degli operatori è

sempre preferibile usare il passaggio per referenza (usando & o il puntatore) poichè si evita la duplicazione dell’oggetto e si rende quindi il programma più veloce

2. Nella variabile restituita dalla funzione : se la funzione ritorna un oggetto vuol dire che il compilatore vi fornisce una copia di un oggetto costruito all’interno della funzione. Non è possibile ritornare l’indirizzo ad un oggetto locale costruito staticamente, si possono invece ritornare indirizzi di oggetti creati dinamicamente (ma ricordarsi sempre che qualcuno dovra’ cancellarli…). Usate la restituzione di un indirizzo solo quando è strettamente necessario. In particolare è necessario farlo nell’overloading di operatori predefiniti che ritornano indirizzi (ad esempio =, += , <<) per mantenere la stesse funzionalità.

43

// Questo file e' stato ottenuto modificando, // per scopo didattico, il file originario// ThreVector.h (e ThreeVector.icc) // della libreria CLHEP // ===========================================// This file is a part of the CLHEP - a Class // Library for High Energy Physics.

// .SS Authors Leif Lonnblad and Anders Nilsson.// ============================================#ifndef TWOVECTOR_H#define TWOVECTOR_H#include <iostream.h>#include <math.h> class TwoVector { private:

double dx, dy; // The components.

public:

 // COSTRUTTORE

TwoVector( float x , float y );

 

// COSTRUTTORE PER COPIA

TwoVector(const TwoVector &);

 

// DISTRUTTORE ~TwoVector();

TwoVector.h

44

// METODI

float x() const; float y() const;

// The components in cartesian // coordinate system. 

void setX(float);

void setY(float);

// Set the components in // cartesian coordinate system.

float phi() const;

// The polar angle.

 

float mag2() const;

// The magnitude squared (rho^2 // in spherical coordinate system).

 

float mag() const;

// The magnitude (rho in spherical // coordinate system).

 

void setPhi(float);

// Set phi keeping mag constant (BaBar).

 

void setMag(float);

// Set magnitude keeping phi constant // (BaBar).

45

// OPERATORI

TwoVector & operator = (const TwoVector &); // Assignment X = Y

// BOOLEANI ( Comparisons ) bool operator == (const TwoVector &) const;

bool operator != (const TwoVector &) const;  

TwoVector operator - () const;

// Unary minus.

 

TwoVector & operator += (const TwoVector &); // Addition ( += ).

TwoVector & operator -= (const TwoVector &); // Subtraction (-= ).

TwoVector & operator *= (float);

// Scaling with real numbers. double dot(const TwoVector &) const;

// Scalar product.

46

TwoVector operator + (const TwoVector &);

// Addition of 2-vectors. 

TwoVector operator – (const TwoVector &);

// Subtraction of 2-vectors. 

double operator * (const TwoVector &);

// Scalar product of 2-vectors.

// Si potrebbe anche definire un operatore

// di moltiplicazione per una

// matrice, che definisce una rotazione // generica.

// Nel nostro caso lo evitiamo, poiche' // non sono state introdotte le matrici

// TwoVector & operator *= (const HepRotation &);

// TwoVector & transform (const HepRotation &);

// Transformation with a // Rotation matrix.

};

47

// dopo il segno }; che indica la fine // della dichiarazione della classe

TwoVector operator * (const TwoVector & , float );

TwoVector operator * (float , const TwoVector & );

// Overloading dell'operatore << (cout)

//

ostream & operator << (ostream &, const TwoVector &);

// Output to a stream.

#include “TwoVector.icc” 

#endif //TWOVECTOR_H

48

// Questo file e' stato ottenuto modificando,// per scopo didattico, il file // originario// ThreVector.icc (e ThreeVector.h) della// libreria CLHEP

// =====================// This file is a part of the CLHEP – // a Class Library for High Energy Physics.// This is the definitions of the // member functions of the// TwoVector class.// =====================  TwoVector::TwoVector(float x, float y): dx(x), dy(y) {}  float TwoVector::x() const { return dx;}  Float TwoVector::y() const { return dy;}  void TwoVector::setX(Float x) { dx = x;}

void TwoVector::setY(Float y) { dy = y;}

TwoVector.icc

49

TwoVector::TwoVector(const TwoVector & p) : dx(p.x()), dy(p.y())) {}  TwoVector::~TwoVector() {}  TwoVector & TwoVector::operator = (const TwoVector & p) { dx = p.x(); dy = p.y(); return *this; }

bool TwoVector::operator == (const TwoVector& v) const { return (v.x()==x() && v.y()==y()) ? true : false; }  bool TwoVector::operator != (const TwoVector& v) const { return (v.x()!=x() || v.y()!=y()) ? true : false; }

TwoVector TwoVector::operator - () const { return TwoVector(-dx, -dy); }

TwoVector & TwoVector::operator += (const TwoVector & p) { dx += p.x(); dy += p.y(); return *this; }

50

TwoVector & TwoVector::operator -= (const TwoVector & p) { dx -= p.x(); dy -= p.y(); return *this; }

TwoVector & TwoVector::operator *= (float a) { dx *= a; dy *= a; return *this; }

float TwoVector::dot(const TwoVector & p) const { return dx*p.x() + dy*p.y(); }

  float TwoVector::mag2() const { return dx*dx + dy*dy; }

  float TwoVector::mag() const { return sqrt(mag2()); }

  float TwoVector::phi() const { return dx == 0.0 && dy == 0.0 ? 0.0 : atan2(dy,dx); }

51

void TwoVector::setMag(float ma){

float ph = phi();

setX(ma* cos(ph)); setY(ma* sin(ph)); }

  void TwoVector::setPhi(float ph){

float ma = mag();

  setX(ma*cos(ph)); setY(ma*sin(ph)); }

   TwoVector TwoVector::operator + (const TwoVector & a) { return TwoVector(dx + a.x(), dy + a.y()); }

  TwoVector TwoVector::operator - (const TwoVector & a) { return TwoVector(dx - a.x(), dy - a.y()); }

double TwoVector::operator * (const TwoVector & a) { return this->dot(a); }

52

 

TwoVector operator * (const TwoVector & p, float a) { return TwoVector(a*p.x(), a*p.y());} 

TwoVector operator * (float a, const TwoVector & p) { return TwoVector(a*p.x(), a*p.y());}

ostream & operator << (ostream & fstream, const TwoVector & v) { 

fstream << " (" << v.x() << "," << v.y() << ") ";

} 

 

non-member operators