Programma C++ - Euclideo

// si possono creare due diversi overloading per il *:

vettore operator*(double) const; // prodotto per scalari nella forma

v * n; // il caso n * v va trattato come

funzione friend... // (vedi sopra)

vettore operator/(double); // divisione di un vettore per un numero:

v1 = v2/5; vettore operator!(); // si decide che l'operatore (unario) "!"

cambia di // segno il vettore...

bool operator==(const vettore &);

// con "==" si vuole in pratica incorporare il controllo

// componente per componente all'interno della classe...

vettore& operator+=(const vettore &);

// qui il tipo di ritorno e' "vettore&" e non "vettore",

// perche' l'operazione, oltre a incrementare il

vettore, // deve restituire il vettore stesso incrementato: non

c'e' // motivo di farne una copia...

vettore operator+(const vettore&);

vettore operator-(const vettore&);

// etc... etc... per aggiungere altri operator overloading

private:

double x,y,z;

};

#endif

#include <iostream>

#include <math.h>

#include "es_6a_class_ter.h"

using namespace std;

vettore::vettore(){

// si e' scelto il vettore nullo come default

x=y=z=0;

}

vettore::vettore(double n_x, double n_y, double n_z){

// e` piu' comodo riutilizzare le set...

set_x(n_x);

set_y(n_y);

set_z(n_z);

}

double vettore::modulus(){

return sqrt(pow(z,2)+pow(y,2)+pow(x,2));

}

double vettore::scalar_prod(const vettore& altroV){

// questa funzione viene eseguita con la chiamata

// double sp = vettore1.scalar_prod(vettore2);

// quindi uno dei vettori e' l'argomento, l'altro

// e' quello di cui viene chiamata la funzione stessa!

return x*altroV.get_x() + y*altroV.get_y() + z*altroV.get_z();

}

vettore vettore::cross_prod(const vettore& altroV){

// Poiche' l'ordine dei fattori conta, si deve

// decidere per convenzione, che, ad esempio,

// vettore u = v.cross_prod(w);

// significa u = v X w e non il contrario...

// si calcolano temporaneamente le componenti

// del prodotto vettoriale in tre doubles...

double cpx,cpy,cpz;

//

// | i j k |

// v X w = | v1 v2 v3 | = (v2*w3-v3*w2)i + (v3*w1-v1*w3)j + (v1*w2-

v2*w1)k

// | w1 w2 w3 |

//

cpx = y*altroV.get_z() - z*altroV.get_y();

cpy = z*altroV.get_x() - x*altroV.get_z();

cpz = x*altroV.get_y() - y*altroV.get_x();

// ... per poi costruire l'oggetto 'vettore' da restituire:

vettore risultato(cpx,cpy,cpz);

return risultato;

}

vettore vettore::operator*(double numero) const{

// questa versione, (vettore) * (numero), permette

// un overloading con funzioni membro:

vettore risultato(numero*x,numero*y,numero*z);

return risultato;

}

vettore vettore::operator/(double numero){

double rx = x/numero, ry = y/numero, rz = z/numero;

vettore risultato(rx,ry,rz);

return risultato;

}

vettore vettore::operator!(){

vettore opposto(-x,-y,-z);

return opposto;

}

bool vettore::operator==(const vettore & altroV){

// invece di scrivere:

// if (uguali...)

// return true;

// else

// return false;

// conviene per brevita':

return (x==altroV.x && y == altroV.y && z == altroV.z);

}

vettore& vettore::operator+=(const vettore & altroV){

// si tratta di sommare altroV al vettore primo operando

// (quello "di cui" viene chiamata la funzione operator+=)

// e poi restituire il tutto.

// Quindi, scrivendo:

// v3 = (v2+=v1);

// viene eseguito

// v2.operator+=(v1)

// che deve sommare v1 a v2, e questa chiamata deve rendere

// a sua volta v2 (dopo la modifica) in modo che venga salvato in v3.

// anche qui, conviene riutilizzare la somma tra vettori, gia' definita:

*this = *this + altroV;

return *this;

}

vettore vettore::operator+(const vettore& addendo2){

// questa funzione effettua un overloading dell'operatore +:

// il compilatore, ogni volta che trova nel programma un'espressione:

// ..... = v1 + v2;

// eseguira' in realta' la funzione v1.operator+(v2), quando v1 e v2 sono

// oggetti vettore. In questo modo un programma che utilizza la classe

// vettore puo' usare la semplice scrittura con l'operatore '+' senza

// dover esplicitamente chiamare funzioni: il comportamento del '+' tra

// due oggetti punto e' scritto una volta per tutte ALL'INTERNO DELLA

CLASSE.

double sumx = x + addendo2.get_x();

double sumy = y + addendo2.get_y();

double sumz = z + addendo2.get_z();

vettore sum(sumx,sumy,sumz);

return sum;

}

vettore vettore::operator-(const vettore& sottraendo){

// come sopra, facendo attenzione a qual e' il

// secondo operando...

double differencex = x - sottraendo.get_x();

double differencey = y - sottraendo.get_y();

double differencez = z - sottraendo.get_z();

vettore difference(differencex,differencey,differencez);

return difference;

}

vettore operator*(double numero, const vettore & v){

// questa e' la versione (numero) * (vettore) e deve essere

// una funzione esterna...

// invece di scrivere due volte il comportamento del prodotto per

// scalari, e' meglio riutilizzare quanto gia' scritto:

return v * numero;

}

ostream& operator<<(ostream& output, const vettore& daStampare){

output << "(" << daStampare.x << "," << daStampare.y << "," <<