Passaggio parametri puntatore

Transcript

1 Passaggio parametri puntatore Corso di Programmazione e Metodi Numerici Ingegneria Aerospaziale BAER Domenico Daniele Bloisi

2 Docenti Metodi Numerici prof. Vittoria Bruni Programmazione prof. Domenico Daniele Bloisi Sito del corso Nota: %7E corrisponde alla tilde ~ Pagina 2

3 Orario delle Lezioni Lunedì Martedì Giovedì Venerdì Aula 15, Via Scarpa 14 Pagina 3

4 Informazioni Generali Ing. Domenico Daniele Bloisi, PhD Dipartimento di Ingegneria Informatica Automatica e Gestionale Via Ariosto 25 (adiacente Piazza Dante, A fermate Manzoni, Vittorio Emanuele, Tram 3 fermata via Labicana) mailto:bloisi@dis.uniroma1.it Pagina 4

5 Ricevimento Martedì DIS via Ariosto 25 Aula docenti adiacente aula A4 Si consiglia di inviare una per conferma e di controllare preventivamente la bacheca degli avvisi Pagina 5

6 Sommario Memoria, indirizzamento e puntatori Tipo void * e conversioni sui puntatori Gestione dinamica della memoria Passaggio dei parametri tramite puntatori Pagina 6

7 Gestione dinamica della memoria Nella Unità 5 è stato presentato il modello di allocazione della memoria tramite stack, che si basa sulle regole di campo d azione (definito staticamente, cioè al momento della compilazione). Attraverso i puntatori, il C++ permette di utilizzare un altro modello di allocazione della memoria, che consente di definire la memoria dinamicamente, cioè al momento dell esecuzione del programma. Questa possibilità risulta particolarmente utile ed importante quando non sono note o prevedibili a priori le dimensioni dei dati in ingresso ad un programma. Pagina 7

8 Operatore new In C++, l allocazione dinamica della memoria avviene attraverso l operatore new, il quale ha come argomento un tipo e restituisce il puntatore ad una locazione di memoria per una variabile di quel tipo. Pagina 8

9 Allocazione di memoria delle variabili puntatore La dichiarazione di una variabile puntatore alloca solo la memoria per il riferimento, non per la variabile puntata. int i,j,k; int *pt_i, *pt_j; // pt_i non allocata pt_j = &j; i = 1; j = 2; k = *pt_i + *pt_j; *pt_i = 10; cout << "i = " << i << endl; cout << "k = " << k << endl; Pagina 9

10 Allocazione di memoria delle variabili puntatore Output i = 1 k = Pagina 10

11 Allocazione di memoria delle variabili puntatore Per allocare memoria dinamicamente si usa l operatore new, al quale va indicato il tipo di dato contenuto nella variabile che sarà creata. Sintassi: variabile puntatore = new ( tipo ); Pagina 11

12 Semantica dell'operatore new Semantica: Viene allocata memoria per una variabile di tipo tipo e il riferimento (cioè l'indirizzo di memoria) viene memorizzato nella variabile puntatore. Esempio: int *pt = new(int); // pt ora punta ad una variabile di tipo int Pagina 12

13 Esempio: allocazione dinamica della memoria int *pt1; // dichiarazione del puntatore ad int pt1 = new(int); // creazione dinamica della variabile int *pt1 = 1; // uso della variabile int allocata //dinamicamente cout << "*pt1 = " << *pt1 << endl; Si noti che per gestire le variabili allocate dinamicamente è necessario utilizzare i puntatori. Pagina 13

14 Modello di allocazione dinamica Se lo spazio di memoria allocabile dinamicamente è esaurito viene restituito il puntatore NULL. int *pt1; // dichiarazione del puntatore ad int pt1 = new(int); // creazione dinamica della variabile int if (pt1 == NULL) { cout << "allocazione fallita" << endl; exit(exit_failure); } Pagina 14

15 Esercizio /*1*/#include <iostream> /*2*/ /*3*/using namespace std; /*4*/ Cosa stampa questo programma? /*5*/int main() { /*6*/ char f = 'b'; /*7*/ char* c = new (char); /*8*/ int *i = new (int); /*9*/ *c = 'a'; /*10*/ *i = -1; /*11*/ cout << (*c > *i) << endl; /*12*/ c = &f; /*13*/ cout << *c << endl; /*14*/} Pagina 15

16 Soluzione Esercizio Output: 1 b Pagina 16

17 Tempo di vita delle variabili allocate dinamicamente Per le variabili allocate dinamicamente il tempo di vita corrisponde al periodo che va dal momento in cui la variabile viene allocata al momento in cui la variabile viene deallocata. Il tempo di vita di una variabile allocata dinamicamente è definito solo al momento dell'esecuzione del programma. Pagina 17

18 Tempo di vita delle variabili allocate dinamicamente Se una variabile allocata dinamicamente non viene deallocata esplicitamente, il suo tempo di vita termina alla terminazione del programma. Può verificarsi il caso in cui una zona di memoria allocata non sia più accessibile, in quanto non ci sono variabili che la riferiscono. Tale zona di memoria rimarrà inutilmente occupata per tutta la durata del programma. Pagina 18

19 Esempio: tempo di vita variabili dinamiche int* creaint (int a) { int* temp = new(int); *temp = a; return temp; } int main () { int* pt2 = creaint(5); cout << "*pt2 = " << *pt2 << endl; } Pagina 19

20 Esecuzione: Tempo di vita variabili dinamiche Il programma precedente stampa *pt2 = 5 poiché la variabile allocata dalla funzione creaint viene restituita al programma principale e rimane accessibile anche al termine della esecuzione della funzione. Le variabili create dinamicamente non rispettano le regole di campo di azione. Pagina 20

21 Esempio: esaurimento della memoria // sciupamemoria int *temp; for (int k = 1; true; k++) { cout << "k = " << k << endl; temp = new (int); } L'esecuzione comporta una richiesta infinita di memoria (la condizione del ciclo è sempre verificata). Pagina 21

22 Esecuzione: esaurimento della memoria L esecuzione produrrà una richiesta infinita di memoria che in C++ comporta (dopo un numero di cicli piuttosto alto) l interruzione dell esecuzione con un messaggio simile al seguente: dynamic(1320) malloc: *** mmap(size= ) failed (error code=12) *** error: can t allocate region Nota: Ad ogni ripetizione del ciclo, la memoria allocata al ciclo precedente risulta inaccessibile. Pagina 22

23 Recupero della memoria garbage collection, che automaticamente recupera la memoria non più utilizzata dal programma; in genere, non disponibile in C++. deallocazione esplicita della memoria tramite l'operatore delete. Pagina 23

24 Deallocazione della memoria Il C++ lascia al programmatore il compito di rilasciare la memoria non più necessaria al programma tramite l operatore delete. Sintassi: delete (variabile puntatore); Pagina 24

25 Operatore delete Semantica: Dealloca (cioè, rende disponibile per usi futuri) la memoria puntata dalla variabile puntatore. Esempio: allocazione della variabile int *pt1; pt1 = new(int); uso della variabile *pt1 = 1; cout << "*pt1 = " << *pt1 << endl; delete(pt1); deallocazione della variabile Pagina 25

26 Problemi di deallocazione della memoria int *pt1; pt1 = new(int); // allocazione della variabile *pt1 = 1; cout << "*pt1 = " << *pt1 << endl; // uso della //variabile delete(pt1); // la locazione di memoria rimane accessibile dopo // delete!!! cout << "after delete" << endl; cout << "*pt1 = " << *pt1 << endl; // la stessa locazione di memoria viene ri-allocata!!! int *pt2 = new(int); cout << "after e-new" << endl; cout << "*pt2 = " << *pt2 << endl; Pagina 26

27 Esecuzioni *pt1 = 1 after delete *pt1 = after e-new *pt2 = *pt1 = 1 after delete *pt1 = after e-new *pt2 = *pt1 = 1 after delete *pt1 = after e-new *pt2 = Pagina 27

28 Discussione: problemi di deallocazione della memoria In questo caso, si può verificare che la memoria rimanga accessibile anche dopo il rilascio ed addirittura che sia ancora immutata (anche se non è garantito). In aggiunta, la riallocazione immediata potrebbe riallocare la variabile nella stessa posizione della memoria e quindi con lo stesso valore (ma anche questo non è garantito). In ogni caso, entrambe le situazioni sopra delineate sono da evitare accuratamente, in quanto fonti di errori e di comportamenti instabili del programma. Pagina 28

29 Puntatori appesi Si consideri il seguente frammento di codice int *pt1; pt1 = new(int); //allocazione della variabile *pt1 = 1; int *pt2; pt2 = pt1; cout << "*pt2 = " << *pt2 << endl; delete(pt1); cout << "*pt2 = " << *pt2 << endl; Pagina 29

30 Esecuzione: Puntatori appesi *pt2 = 1 *pt2 = In questo caso, il rilascio della memoria puntata dalla variabile pt1 lascia la variabile pt2 puntare ad una locazione di memoria rilasciata e quindi suscettibile di modifiche arbitrarie da parte del sistema operativo. Questa situazione di puntatore appeso (dangling) è da evitare assolutamente in quanto fonte di errori difficili da individuare. Pagina 30

31 Passaggio di parametri L uso di variabili di tipo puntatore consente di simulare la modalità di passaggio dei parametri per riferimento. Nel passaggio di parametri per valore, in genere utilizzato per i dati di tipo primitivo, il parametro formale può essere considerato come una variabile locale che viene inizializzata al momento della chiamata della funzione con il valore corrispondente al parametro attuale. Pagina 31

32 Passaggio di parametri Il passaggio di parametro per valore effettuato con il tipo puntatore consente di aggirare una proprietà cruciale del passaggio di parametri per valore, cioè la garanzia che la funzione non abbia effetti sul programma chiamante (ad eccezione della restituzione del valore calcolato). Pagina 32

33 Esempio: passaggio parametri puntatore void swap(int *a, int *b) { int temp; temp = *a; *a = *b; *b = temp; } Pagina 33

34 Esempio: passaggio parametri puntatore int main (){ int j,i; i = 12; j = 27; cout << "i = " << i << endl; cout << "j = " << j << endl; swap(&i, &j); cout << "after swap" << endl; cout << "i = " << i << endl; cout << "j = " << j << endl; } Pagina 34

35 Esecuzione i = 12 j = 27 after swap i = 27 j = 12 Pagina 35

36 Nonostante il passaggio di parametri sia per valore, il risultato dell esecuzione della funzione swap consiste proprio nel modificare il valore di due variabili del programma principale. Passando alla funzione i puntatori a due variabili è possibile modificare il valore delle variabili puntate, anche se il valore delle variabili puntatore rimane inalterato. L uso dei puntatori nel passaggio di parametri per valore consente di effettuare in pratica il passaggio di parametri per riferimento. Pagina 36

37 Passaggio per valore VS passaggio tramite puntatori void swap(int *a, int *b) { int temp; temp = *a; *a = *b; definizione *b = temp; } void swapval(int a, int b) { int temp; temp = a; a = b; definizione b = temp; } swap(&x, &y); invocazione swapval(x, y); invocazione Cosa succede se si invoca swapval(&x, &y);? error: invalid conversion from 'int*' to 'int' Pagina 37

38 Chiamata tramite parametri puntatore (per indirizzo): funzione chiamante Quando la funzione viene chiamata, devono essere passati come parametri gli indirizzi delle variabili il passaggio degli indirizzi potrà essere ottenuto applicando l operatore di indirizzo & alla variabile che deve essere modificata sono passate le celle fisiche dove i valori sono memorizzati &a a b &b 2 3 int a; int b; a = 2; b = 3; f(&a, &b); Pagina 38

39 Chiamata per indirizzo Nell intestazione della funzione chiamata deve essere usato l operatore di deriferimento per le variabili passate per indirizzo pa pb &pa &a &pb &b void f(int *pa, int *pb) { *pa = 6; *pb = 7; } Pagina 39

40 Chiamata per indirizzo: esecuzione a &a 6 int a; int b; a = 2; b = 3; f(&a, &b); pa &pa b &b 7 int *pa = &a; pb &pb void f(int *pa, int *pb) { *pa = 6; *pb = 7; } Pagina 40

41 Passaggio per riferimento VS passaggio tramite puntatori void swap(int *a, int *b) { int temp; temp = *a; *a = *b; definizione *b = temp; } void swapref(int &a, int &b) { int temp; temp = a; a = b; definizione b = temp; } swap(&x, &y); invocazione swapref(x, y); invocazione Cosa succede se si invoca swapref(&x, &y);? error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int*' Pagina 41

42 Vantaggi del passaggio tramite puntatori VS passaggio per valore Il passaggio di parametri di tipo puntatore è particolarmente utile quando i dati che devono essere scambiati tra funzione chiamata e programma chiamante sono voluminosi. Il passaggio tramite puntatori risulta molto più efficiente sia in termini di occupazione di memoria che di tempo di calcolo (infatti, occorre la copia del solo puntatore ai dati, non di tutto l insieme dei dati). Pagina 42

43 Vantaggi del passaggio per riferimento VS passaggio tramite puntatori Evidentemente l uso dei puntatori nel passaggio di parametri per valore consente di effettuare in pratica il passaggio di parametri per riferimento. Quest ultimo, risulta, tuttavia, più chiaro e non richiede la manipolazione esplicita dei puntatori nel parametro attuale. Pagina 43

44 Parametri per riferimento costanti Quando il parametro passato per riferimento non deve essere modificato dalla funzione, si può utilizzare lo specificatore const void f (const double &x) { x=2.0; //Errore: x non può essere modificato return; } Pagina 44

45 Esempio #include <iostream> #include <cstdlib> using namespace std; void f (const double &x) { x=2.0; // Errore: x non può // essere modificato return; } int main () { double d; reference 'x' d = 1; f(d); cout << "d = " << d << endl; return EXIT_SUCCESS; } In function 'void f(const double&)': error: assignment of read-only Pagina 45

46 Valori restituiti di tipo puntatore e riferimento Le funzioni C++ possono restituire valori di tipo puntatore o di tipo riferimento. Pagina 46

47 Valori restituiti di tipo puntatore double *puntatore (double a) { double *r = new (double); *r = a; return r; } la funzione puntatore crea un puntatore ad una variabile di tipo double e la inizializza con il valore passato come argomento int main () { double *pd = puntatore(5.4); cout << "pd = " << pd << endl; cout << "*pd = " << *pd << endl; return EXIT_SUCCESS; } Pagina 47

48 Valori restituiti di tipo riferimento double &ref (double &a) { return a; } int main () { double d1,d2; d1 = 1; ref(d2) = d1; cout << "d2 = " << d2 << endl; return EXIT_SUCCESS; } Pagina 48

49 Variabili riferimento In C++ lo stesso meccanismo che si usa nel passaggio di parametro per riferimento per far in modo che due variabili facciano riferimento alla stessa locazione di memoria, si può utilizzare anche tra due variabili. int x; int &y = x; Da questo punto in poi le due variabili x ed y fanno riferimento alla stessa locazione di memoria. Pagina 49

50 Appendice: memoria 0 Memoria La memoria del calcolatore può essere idealmente descritta come un insieme di celle ORDINATO UNIVOCAMENTE n Pagina 50

51 Appendice: assegnazione 0 int x = 1; n 1 x L istruzione di assegnazione permette di scrivere un valore all interno di una cella simboleggiata da un nome di variabile Pagina 51

52 Appendice: valore di una variabile 0 int x = 1; cout << "x = " << x; Produce x x = 1 n Tramite il nome di una variabile è possibile leggere il contenuto della cella simboleggiata da quella variabile Pagina 52

53 Appendice: indirizzo di una variabile 0 int x = 1; cout << "&x = " << &x; Produce x &x = n Tramite l operatore & applicato al nome di una variabile è possibile leggere l indirizzo della cella simboleggiata da quella variabile Pagina 53

54 Appendice: puntatore n x_ptr x int x = 1; int *x_ptr; x_ptr = &x; cout << "*x_ptr = " << *x_ptr << endl; cout << "&x_ptr = " << &x_ptr << endl; cout << "x_ptr = " << x_ptr << endl; Produce *x_ptr = 1 &x_ptr = x_ptr = Pagina 54

55 Appendice: valore tramite un puntatore x_ptr x Tramite l operatore * applicato al nome di un puntatore è possibile leggere il contenuto della cella il cui indirizzo è contenuto nella cella simboleggiata da quel puntatore n Pagina 55