Laboratorio di Programmazione aa 2012/2013 Riferimenti, Costruttori, Distruttori, Assegnazione

Transcript

1 Laboratorio di Programmazione aa 2012/2013 Riferimenti, Costruttori, Distruttori, Assegnazione Giorgio Grisetti 28 marzo 2013 In questa lezione vedremo come il C++ introduce una nuova modalità per passare oggetti modificabili: il riferimento. Analizzeremo inoltre in maggior dettaglio cosa avviene quando creiamo e distruggiamo un oggetto e vedremo come è possibile intervenire in queste fasi. Lo scopo è quello di introdurre dei meccanismi che ci permettano di definire nuovi tipi di dato che si comportino in maniera analoga a quella dei tipi definiti. 1 Riferimento ad un Tipo Finora abbiamo visto che, per passare ad una funzione un argomento che la funzione deve modificare, eravamo obbligati a passare il puntatore a tale argomento. Se, ad esempio, abbiamo una funzione del tipo: void settoone(int* i){ *i=1; per poterla invocare possiamo scrivere: { int k; settoone(&k); Il C++ rispetto al C aggiunge un po di zucchero sintattico a questa procedura, permettendoci di definire dei riferimenti ad un tipo di dato. Un riferimento si dichiara così: <type>& nomeriferimento; Ad esempio, la funzione settoone(int* i) diventerà: 1

2 void settoone(int& i){ i=1; Un tipo riferimento è accessibile come se fosse un tipo normale, con la differenza che è possibile modificarlo. Al suo interno il compilatore tratta un riferimento come un puntatore. La differenza rispetto all uso di puntatori è che un riferimento punta sempre (a meno di errori particolari), ad una locazione di memoria valida. Per essere creato, infatti, un riferimento ha bisogno di una variabile concreta. É di aiuto pensare ad un riferimento come ad un puntatore dereferenziato (*p). 2 La tormentata vita delle variabili Durante l esecuzione, è comune che un programma allochi e deallochi e copi un grande numero di variabili. In particolare: ogni volta che il flusso del programma entra in un blocco in cui è dichiarata una variabile, la corrispondente memoria viene allocata nello stack. ogni volta che il flusso del programma esce da un blocco, le corrispondenti variabili vengono eliminate Quando viene invocata una funzione: prima dell esecuzione della funzione stessa, allochiamo memoria nello stack per mantenere i valori dei suoi parametri, e copiamo in questa memoria il valore delle variabili passate come argomento dal chiamante tali variabili vivranno tutto il tempo della funzione quando la funzione termina, le sue variabili temporanee (inclusi i parametri) vengono distrutte l eventuale valore di ritorno viene copiato alla destinazione indicata dal chiamante, tramite l istruzione return. ogni volta che invochiamo una malloc od una free, allochiamo nello heap memoria per una variabile. Se la nostra variabile è una struct complessa che contiene puntatori ad altri elementi, la sua creazione comporta l invocazione di opportune funzioni di inizializzazione (construct). Stessa cosa accade nel momento in cui distruggiamo una variabile (dstruct). Ovviamente dobbiamo ricordarci sempre di compiere tali operazioni, e dobbiamo farlo in modo esplicito. Il C++ permette di definire le operazioni che devono essere eseguite dal compilatore nel momento in cui una variabile viene: creata, copiata, assegnata, 2

3 distrutta, mediante la definizione di appositi metodi che verranno invocati in modo automatico. Questo ha il vantaggio non indifferente di sollevare l utente dal compito di invocare esplicitamente le funzioni che si occupano di questo aspetto. Nel seguito vedremo come. 3 Costruttore Un costruttore è un metodo particolare di una classe che si dichiara così: struct MyStruct {.. MyStruct( <parameter list>); ; dove <parameter list> rappresenta la lista dei parametri, eventualmente vuota. Notate che un costruttore non ha argomenti di ritorno, neanche void. Nell implementazione scriveremo MyStruct::MyStruct(<parameter list>){ Quando creiamo una variabile di tipo MyStruct, dovremo invocare il costruttore in modo esplicito: MyStruct s(10); Possiamo aggiungere un costruttore alla struct vec in questo modo: struct Vec{ double* data; int dimension; Vec(int size); L implementazione del costruttore sarà tipo la seguente: Vec::Vec(int size) { this->data = vec_alloc(size); this->dimension = size; Se ora vogliamo creare un elemento della struct vec, che si auto inizializza, scriveremo Vec v1(100); 3

4 Nel caso in una struct non dichiarassimo alcun costruttore, verrà utilizzato il costruttore di default del C++, che non fa nulla. Se dichiariamo un costruttore con zero argomenti, (es. Vec::Vec()) tale costruttore verrà invocato al posto di quello di default. Ovvero, scrivendo: Vec v1; verrà invocato il nostro Vec::Vec(), non quello di default del C++. All interno di una struct possiamo definire più costruttori, purché questi abbiano una lista di argomenti (la parameter list che abbiamo visto prima) diversi. Il costruttore da invocare verrà scelto in base ai lista dei parametri passati come argomento. Ad esempio, possiamo avere tre costruttori: struct Vec{ double* data; int dimension; Vec(); Vec(int size); Vec(int size, double defaultvalue); Nel main, possiamo invocarli in modo esplicito:.. Vec v1(); // chiama il costruttore Vec() Vec v2(5); // chiama il costruttore Vec(int) Vec V3(5, 0.1); // chiama il costruttore Vec(int, double) É importante considerare che quando viene invocato un costruttore la memoria per la struct è già stata allocata, ma i puntatori al suo interno non sono stati inizializzati 1. Ergo, nel costruttore di Vec abbiamo rimosso la malloc per la struct. Per fare un po il punto: Un costruttore viene invocato ogni volta che si dichiara una variabile Se passiamo una lista di parametri vuota (quindi nessun parametro), viene invocato il costruttore di default Se si dichiarano solo costruttori con argomenti, questi nascondono quello di default, che puo essere recuperato riscrivendo il metodo MyStruct::MyStruct(). 4 Costruttore di Copia Un costruttore con una lista di argomenti particolare riveste un ruolo fondamentale nel passaggio di parametri e dei valori di ritorno delle funzioni. Tale costruttore è chiamato costruttore di copia, e si dichiara così: 1 questo non è necessariamente vero nel caso in cui struct derivi da un altra mediante il meccanismo dell ereditarietà. Approfondiremo questo aspetto nel seguito del corso. Per ora prendete questa affermazione per buona. 4

5 struct MyStruct { MyStruct(const MyStruct& s); ; Il costruttore di copia deve avere il comportamento specifico di copiare il parametro nell oggetto che si va creando. Il qualificatore const prima del riferimento serve a dire al compilatore che il parametro s, sebbene passato per riferimento, non verrà modificato. Ad esempio il costruttore di copia della nostra struct Vec sarà Vec::Vec(const Vec& v){ this->data = vec_alloc(v.dimension); this->dimension = v.dimension; memcpy(this->data, v.data, sizeof(double)*this->dimension); Notate che l accesso ai campi del parametro v avviene tramite l operatore. e non tramite ->. Questo infatti non è più un puntatore. Un costruttore di copia è invocato: 1. Ogni volta si passano dei parametri per valore 2. Ogni volta che viene invocata una return di un parametro passato per valore 3. In modo esplicito Il costruttore di copia non viene invocato se si passano puntatori ad un oggetto oppure se si passano riferimenti a tale oggetto. Ad esempio, possiamo riscrivere la funzione dot, che prende come parametro un vettore passato per riferimento: double Vec::dot(Vec b){ if (this->dimension!=b.dimension){ printf("fatal, attempt to dot product vectors of different dimensions"); return 0; return vec_dot(this->data, b.data,this->dimension); Nel main: Vec v1(100); Vec v2(100); double d = v1.dot(v2); // chiama il costruttore di copia per passare v2. Vec v3(v1); // chiama il costruttore di copia in modo esplicito; 5

6 5 Distruttori Con i costruttori abbiamo automatizzato il comportamento del compilatore nella creazione di oggetti. Possiamo fare lo stesso per la loro distruzione? Ovvero, possiamo dire che ogni volta che si vuole liberare memoria per una variabile, prima di liberarla occorre compiere alcune operazioni (ad esempio liberare altre zone di memoria puntate)? Se così non fosse, non starei scrivendo questo paragrafo. La cosa si fa mediante il metodo distruttore, che si dichiara come segue: struct MyStruct { ~MyStruct(); ; nell implementazione MyStruct::~MyStruct(){ Contrariamente ai costruttori, che potete definire a iosa, deve esistere un solo distruttore per struct e deve avere zero argomenti e zero valori di ritorno. Notate il simbolo tilde prima del nome del metodo (anche se è venuto un po storto). Nella nostra struct Vec il distruttore sarà così: Vec::~Vec(){ vec_free(this->data); Confrontatelo con il vecchio metodo destruct e meditate. Anche il distruttore non libera la memoria della struct, ma solo la roba appesa. Il distruttore viene invocato quando una variabile viene eliminata. Questo può avvenire nelle circostanze descritte nella sezione 2, ma prima di liberare la memoria della struct. 6 Assegnazione Con i meccanismi di sopra, possiamo creare, copiare e distruggere oggetti in modo abbastanza elegante. Se però vogliamo assegnare ad un oggetto il valore di un altro dobbiamo ancora ricorrere ad un metodo aggiuntivo (vedi vector_assign, la cui sintassi è molto meno intuitiva dell a=b;, che ci aspetteremmo se i due oggetti fossero tipi primitivi. La cosa è però resa possibile ricorrendo al meccanismo dell overloading: è un meccanismo molto potente che permette di ridefinire praticamente ogni operatore del C++ (inclusi gli usuali +,-,*,/. L overloading si effettua come segue: struct Vec{ double* data; int dimension; Vec& operator=(const Vec& v); 6

7 L implementazione del metodo è la seguente: Vec& Vec::operator =(const Vec& src) { resize(src.dimension); memcpy(this->data, src.data, src.dimension*sizeof(double)); return *this; // note that the = return a reference to the destination. ed avrà un comportamento analogo alla vecchia assign(). Ora finalmente possiamo eseguire un operazione di assegnazione, come se si trattasse di tipi primitivi, come segue: Vec v1(); Vec v2(); v1=v2; 7 Qualificatore const Nelle sezioni precendeti è comparsa una nuova parola chiave del C++, const. Il const e un qualificatore che serve a dire che una variabile non deve essere modificata. Metterlo dove serve aiuta a evitare errori, in quanto modifiche di una variabile all interno del corpo di una funzione in cui la variabile è dichiarata const verranno trattati come errori di compilazione. Possiamo usare const anche per dichiarare che un metodo non modifica l oggetto di invocazione, mettendo il qualificatore dopo la lista degli argomenti e prima del ; o della {. Ad esempio, il metodo print sara ragionevolmente const: void Vec::print() const; Il qualificatore const entra a far parte del tipo, perciò const Vec& e Vec& sono a tutti gli effetti due tipi differenti. 8 Esempio: la classe Vec Concludiamo questa sezione con una versione della struct Vec (che ora assomiglia sempre più ad una classe), in cui abbiamo introdotto costruttori e distruttori e aggiunto variabili passate per riferimentio dove necessario. #ifndef _LP_VECTOR_H_ #define _LP_VECTOR_H_ struct Vec{ double* data; int dimension; Vec(int size); // was construct(int size); Vec(const Vec& Vec); // was clone(vec*v) Vec& operator=(const Vec& v); // was assign() ~Vec(); // was destruct 7

8 void resize(int size); void fillrandom(); void read(); // reads something in the calling object void print() const; void scale(double d); void scaledsum(const Vec& src, double d); // double dot(const Vec& b); void convolve(const Vec& src1, const Vec& src2); int compare(const Vec& v2) const; ; #endif Il file.cpp sarà: #include "stdio.h" #include "vecutils.h" #include "lp_vec.h" #include <stdlib.h> #include <string.h> Vec::Vec(int size) { this->data = vec_alloc(size); this->dimension = size; Vec::Vec(const Vec& v){ this->data = vec_alloc(v.dimension); this->dimension = v.dimension; memcpy(this->data, v.data, sizeof(double)*this->dimension); Vec::~Vec(){ vec_free(this->data); Vec& Vec::operator =(const Vec& src) { resize(src.dimension); memcpy(this->data, src.data, src.dimension*sizeof(double)); return *this; void Vec::read(){ this->data = vec_read(&this->dimension); void Vec::print() const { 8

9 vec_print(this->data, this->dimension); void Vec::fillRandom(){ for (int i=0; i<this->dimension; i++){ this->data[i]=drand48(); void Vec::resize(int size) { if (this->dimension == size) return; vec_free(this->data); this->data = vec_alloc(size); this->dimension = size; void Vec::scale(double d){ vec_scale(this->data,this->dimension, d); void Vec::scaledSum(const Vec& src, double d){ if (this->dimension!=src.dimension){ printf("fatal, attempt to sum vectors of different dimensions"); return; vec_scaled_sum(this->data, src.data, src.dimension, d); double Vec::dot(const Vec& b){ if (this->dimension!=b.dimension){ printf("fatal, attempt to dot product vectors of different dimensions"); return 0; return vec_dot(this->data, b.data,this->dimension); void Vec::convolve(const Vec& src1, const Vec& src2) { resize(src1.dimension + src2.dimension); vec_convolve(this->data, src1.data, src1.dimension, src2.data, src2.dimension); int Vec::compare(const Vec& v2) const{ for (int i=0; i<this->dimension && i<v2.dimension; i++){ if (this->data[i]<v2.data[i]) return -1; else if (this->data[i]>v2.data[i]) return 1; 9

10 if (this->dimension<v2.dimension) return -1; if (this->dimension>v2.dimension) return 1; return 0; Notate che il main si semplifica notevolmente. #include <stdio.h> #include "lp_vec.h" int main(int argc, char** argv){ printf("input a vector\n"); Vec v1(0); v1.read(); printf("the vector you entered is\n"); v1.print(); Vec v2(0); do { printf("input another vector (of dimension %d)\n", v1.dimension); v2.read(); if (v2.dimension!= v1.dimension) { printf("wrong dimension, you netered %d, i required %d\n", v1.dimension, v1.dimension); while (v2.dimension!= v1.dimension); printf("the vector you entered is\n"); v2.print(); // copying the second vector using the copy constructor; Vec v2copy(v2); printf("the copy of the second vector is\n"); v2copy.print(); //multiplying the first vector by a scalar; double scale; printf("v1 is\n"); v1.print(); printf("insert a scale, to multiply the first vector\n"); scanf("%lf",&scale); v1.scale(scale); printf("v1*scale is\n"); v1.print(); 10

11 v2copy.scaledsum(v1, -1); printf("v2-v1*scale is\n"); v2copy.print(); printf("v1*v2 is %lf\n", v1.dot(v2)); Vec v3(0); v3.convolve(v1,v2); printf("the convolution is\n"); v3.print(); 9 Esercizio Obbligatorio Per la prossima puntata, prendete in mano la struct Mat introdotta durante l esercitazione e modificatela in modo da supportare costruttori e distruttori. Fate ALMENO il.h. 11