Settima esercitazione (classi)

Esercizio 1
Esercizio 2

Passaggio di oggetti a funzioni (o metodi)

Il passaggio per valore di un oggetto:

funzione(Classe oggetto);

può essere molto pesante perchè implica la copia di ciascun membro della classe.
Al contrario il passaggio della referenza
funzione(Classe& oggetto);

è più efficiente perchè indica solo l'indirizzo di memoria dove l'oggetto è immagazzinato.
Al tempo stesso però permette la modifica dell'oggetto passato !
Se si vuole fare in modo che l'argomento non possa essere modificato si deve usare la keyword
const
funzione(const Classe& oggetto);

Puntatore all'oggetto medesimo (this)

All'interno di un metodo di una classe il puntatore a oggetto this indirizza l'oggetto al quale è
applicato il metodo;
Esercizio 1 (classe vettore 3D)
Definire una classe Vector che rappresenti vettori (o punti) 3D tramite membro privato statico
(array a 3 dimensioni).
Implementare
• costruttore default
• costruttore che prende come parametri le coordinate
• metodi per settare/ottenere il valore delle variabili (X, Y, Z)
• accesso alternativo per settare/ottenere le componenti ridefinendo l'operatore []
double& Vector::operator[](int i)

Si aggiungano inoltre seguenti metodi:

• operatore + che somma due vettori
• operatore - che calcola la differenza di due vettori
• operatore * che calcola il prodotto scalare di due vettori
• operatore ^ che calcola il prodotto vettore di due vettori (operazione definita solo per N=3)
A×B=( AyBz- ByAz , AzBx- AxBz , AxBy- AyBx )
• modulo di un vettore
Creare un programma che, letti tre vettori da terminale, verifichi le seguenti identità vettoriali

A·(B×C) = B·(C×A) = C·(A×B)

(A×B)2 = A2B2 - (A·B)2
Distruttore, costruttore di copia ed assegnazione (facoltativo)
 • Il distruttore ha la forma
~Classe()

Ce ne può essere al massimo uno.

Viene chiamato quando si esce dal campo di visibilità di un oggetto della classe allocato
staticamente o quando si applica l'operatore delete ad un oggetto della classe allocato
dinamicamente.
Se non è definito il compilatore implementa il distruttore banale che distrugge l'oggetto (con
i suoi membri).
• Il costruttore di copia è un tipo di costruttore che serve per inizializzare uno strumento
tramite un'altro oggetto. Il costruttore di copia è una funzione membro che ha lo stesso nome
della classe ed ha come argomento una referenza ad un oggetto della classe stessa
Classe(const Classe &)

Se non è definito il compilatore crea per default una copia bit a bit, cioè ogni dato membro
viene copiato. Il costruttore di copia viene invocato quando:
• inizializzazione esplicita
Classe obj2;
Classe obj1(obj2);
// equivalentemente: Classe obj1 = obj2;

• passaggio per valore ad una funzione

• operatore di assegnazione
Classe& operator=(const Classe &)

assegna all'oggetto a sinistra l'oggetto a destra.

Se non è definito il compilatore creare l'operatore banale che, come nel caso precedente,
copia bit a bit.
Classe obj2,obj1;
//...
obj2=obj1;

Se le variabili membri della classe sono variabili statiche non vi è alcun problema: le versioni
default sono sufficienti.
Se invece all'interno dei membri della classe c'e' un vettore allocato dinamicamente (il membro è il
puntatore):
• il distruttore default distrugge il puntatore (cioè la variabile che contiene l'indirizzo di
memoria) ma non la zona di memoria allocata;
• il costruttore di copia crea un copia che condivide la stessa zona di memoria per la variabile
allocata dinamicamente (non è una vera copia).
• l'operatore di assegnazione copia l'indirizzo di memoria (i due oggetti condividono la stessa
area di memoria)
Esercizio 2 (vettore a N dimensioni) (facoltativo)
Creare un programma che legga i dati contenuti in punti3d.dat (vettori 3d) ed utilizzando la classe
così definita trovi:
• i due vettori più collineari, cioè con θ minore (cosθ=v_1*v_2/(|v_1||v_2|))
Attenzione: quando si alloca dinamicamente un array di oggetti per ciascuno di essi viene chiamato
il costruttore default (quello senza argomenti, aggiungetelo alla classe). Per cui se volete allocare un
array di N vettori a m componenti utilizzando un costruttore diverso da quello default dovete creare
un array di puntatori ad oggetto ed allocare poi ogni oggetto tramite il puntatore.