Fondamenti di Informatica II 10. Puntatori e gestione della memoria

Transcript

1 Cosa sono i puntatori? Fondamenti di Informatica II 10. Puntatori e gestione della memoria I puntatori sono fondamentalmente delle variabili che non contengono un valore numerico o alfanumerico, ma un puntatore (ossia un indirizzo) alla locazione di memoria dove è memorizzato un certo valore (intero, reale o carattere) La definizione di una variabile puntatore avviene nello stesso modo con cui si definisce una variabile, eccetto che dobbiamo aggiungere un asterisco tra il tipo e l indentificatore del puntatore (ossia il nome della variabile puntatore) nel nome conviene indicare una p iniziale per ricordarci che è un puntatore Esempi: Corso di Laurea in Ingegneria Informatica A.A Semestre Corso (A-M) int* pone; short* pnum; Persona* pdip; double** ptot; // puntatore ad un int // puntatore ad uno short int // puntatore ad un tipo Persona (p.e. struct) // puntatore ad un puntatore a double Prof. Giovanni Pascoschi 2 Uso dei puntatori Esempio Esempio int* pone; int* ptwo; int num1, num2; pone = &num1; ptwo = &num2; L operatore & deve essere letto come l indirizzo di (Address-of) e restituisce l indirizzo di memoria della variabile e non la variabile. L operatore * deve essere letto come il contenuto della locazione di memoria puntata da a meno che non si trovi in una definizione di variabili puntatore del tipo 'int* pone. L operatore * prende il nome di operatore di dereference (deferenziamento). #include <iostream> using namespace std; int nnumber; int* ppointer; int main() { nnumber = 15; ppointer = &nnumber; // stampiamo il valore di nnumber cout<< "nnumber is equal to : <<nnumber<<endl; // ora, alteriamo nnumber per mezzo di ppointer *ppointer = 25; // stampiamo il nuovo valore di nnumber cout<<"nnumber is equal to: <<nnumber<<endl; return 0; 3 4

2 Puntatori : cosa succede nella memoria Cosa succede nella memoria #include <iostream> using namespace std; Le definizioni int n=7 e int* pnum, determinano la presenza di due locazioni di memoria allocate nell area dati int n=7; int* pnum; n 8A00 8A01 7 pnum = &n; *pnum = 13; return 0; pnum 8A02 8A03 Si suppone che il tipo int richieda 2 bytes di memoria ed assumendo che un puntatore occupi anch esso 2 bytes. la figura sono anche indicati gli indirizzi (in esadecimale) di ciascun byte. L indirizzo di n è per definizione l indirizzo del primo byte, cioè 8A00. L indirizzo di pnum è 8A Cosa succede nella memoria Esempio Le istruzioni: p=&n; *p=13; hanno il seguente effetto in memoria: #include <iostream> using namespace std; int x = - 5, y = 10; int* p; n pnum 8A00 8A01 8A A00 intmain( ){ p = &y; x = *p; return 0; // equivale all istruzione x = y 8A03 7 8

3 Esempio Esempio x 8A00 8A01-5 Le istruzioni: p = &y; x = *p; hanno il seguente effetto in memoria y 8A02 8A03 10 x 8A00 8A01 10 p 8A04 8A05 y 8A02 8A03 10 p 8A04 8A05 8A Puntatori : casi particolari Uso dei puntatori : compatibilità di tipo tra puntatori float* uno, due; float* uno, float* due; int Intero = 10; // dichiarazione due puntatori a float? NO // dichiarazione due puntatori a float? SI Un puntatore a un tipo T può contenere solo indirizzi di variabili di tipo T. Quindi, tipi di puntatori diversi sono incompatibili fra loro NO CASTING Esempi int x = 10; float * py; py = &x; // non si puo fare // const int* Puntatore = &Intero; //dichiarazione puntatore costante a intero? NO int x = 10,int * py; float* pz; int* const CostantePuntatore = &Intero; /* dichiarazione puntatore costante a intero? SI */ py = &x; pz = py; // non si puo fare // const int* const CostantePuntatoreACostante = &Intero; /* dichiarazione puntatore costante a costante di tipo intero */ void* PuntatoreGenerico /*dichiarazione puntatore generico puo puntare a un qualsiasi tipo */ MOTIVO:l informazione sul tipo del puntatore serve a dedurre il tipo dell oggetto puntato, che è indispensabile per effettuare correttamente il dereferenziamento 11 12

4 Esempio : operazioni sui puntatori Uso dei puntatori : operazioni con i puntatori #include <iostream> using namespace std; int a=4, b=15; int* pnum; pnum=&a; (*pnum)++; // incrementa a (parentesi necessarie) // pnum = &b; (*pnum)- -; // decrementa b cout<<a<<endl; // stampa 5 cout<<b<<endl; // stampa 14 return 0; Se P è un puntatore, ed n è un int (eventualmente anche negativo) cosa significa un espressione come : P+n??? Denota un altro puntatore, che punta n locazioni dopo la locazione puntata da P ( locazioni non byte!) Per locazione si intende l insieme di byte necessari a memorizzare una variabile di un certo tipo (provare a utilizzare p.e. sizeof(float) ) Se int richiede 2 (o 4) byte 1 locazione = 2 bytes Se float richiede 4 byte 1 locazione = 4 bytes Se double richiede 8 byte 1 locazione = 8 bytes Uso dei puntatori : operazioni con i puntatori Uso dei puntatori : inizializzazione dei puntatori Se n è negativo, la locazione denotata da P+n precede in realtà quella puntata da P Analogamente, se P e Q sono due puntatori allo stesso tipo T, l espressione P-Q denota il numero (intero) di celle che separano Q da P (eventualmente negativo se Q precede P) NOTA: operazioni tra variabili puntatori a tipi diversi (P puntatore a tipo int, Q puntatore a tipo float), come P+Q, sono illegali E buona regola non lasciare indefiniti i puntatori, per cui è bene inizializzarli subito dopo il momento in cui vengono dichiarati Esempio int *p; p=0; oppure p=null; NULL è una costante simbolica dichiarata anche nella libreria <iostream> 0 (zero) è l unico valore int che si può assegnare ad un puntatore 15 16

5 Vettori e puntatori Vettori e puntatori Un vettore (array) A è un insieme finito di N variabili dello stesso tipo, ognuna identificata da un indice Un vettore è organizzato come un puntatore costante, inizializzato a puntare un area di memoria opportunamente allocata al momento della dichiarazione Il nome del vettore A rappresenta in realtà l indirizzo iniziale dell area di memoria associata al vettore stesso Le seguenti notazioni sono equivalenti: int vett[10]; int* vett; L operatore [ ], applicato ad un nome di vettore, accede alla i-esima cella del vettore L operatore *, applicato ad un puntatore, accede alla variabile da esso puntata Poiché vett è il puntatore al primo elemento del vettore, vale la relazione: *vett = vett[0]; *(vett+1) = vett[1];.. *(vett+n-1) = vett[n-1]; Vettori e puntatori (aritmetica dei puntatori) Vettori e puntatori : esempio Le relazioni viste per i vettori: *A = A[0] *(A+i) = A[i] sono un applicazione dell aritmetica dei puntatori. A denota il puntatore costante alla cella di memoria che contiene la prima variabile del vettore (A+i) denota un altro puntatore che punta i locazioni dopo la locazione puntata da A *(A+i) denota il contenuto della locazione di memoria che si trova i locazioni dopo la locazione puntata da A int Array[ ] = { 1, 2, 3, 4, 5 ; int* pa = Array; // equivale a pa = &Array[0]; cout << pa[3] << endl; // pa[3] equivale a *(pa+3); pa[4] = 7; // equivalente a *(pa+4) = 7; 19 20

6 Puntatori e stringhe Array di stringhe Una stringa si puo anche definire in maniera analoga al C: char Array[ ] = "Una stringa"; char* pa = Array; cout << Array << " == " << pa << endl; // non è necessario usare *pa cout << Array[5] << " == " << pa[5] << endl; // stampa solo un elemento Un array di stringhe si puo dichiarare in diversi modi: string Array[10]; // array di stringhe (stile C++) char Array [10][20]; // matrice di caratteri char* parr[10]; // array di puntatori a carattere Puntatori a puntatore Puntatori a strutture Un puntatore puo puntare qualunque tipo anche un altro puntatore int A = 10; int* pa = &A; int** ppa = &pa; A = 50; // assegna ad A 50 *pa = 50; // assegna ad A 50 **ppa = 50; // assegna ad A 50 Un puntatore puo puntare qualunque tipo anche una struttura si usa l operatore -> Esempio: struct data { int giorno; string mese; int anno; ; data* pdata; data d; pdata = &d; (*pdata).giorno = 31;//per assegnare al campo giorno della struttura d il valore 31 opp. pdata-> giorno = 31; //per assegnare al campo giorno della struttura d il valore

7 Puntatori a funzione Puntatori a funzione : esempio Un puntatore puo puntare anche all indirizzo del nome di una funzione (in maniera analoga al nome di un array) Esempio: int funz(int); // dichiarazione della funzione int (*pf) (int); /* dichiarazione di pf puntatore a una funzione che restituisce un intero e utilizza un parametro intero*/ pf = &funz; // assegnazione di pf alla funzione funz float (*fp) (int x, int y); fp=&funz;... funz(x,y); // chiamata della funzione (*fp) (x,y); // metodo equivalente di chiamata della funzione float funz(int a, int b) { return a+b; Chiamata di funzione con passaggio di puntatore a funzione Array di Puntatori a funzione void (*funz2) ( ); funz1(funz2);... void funz1 (int (*f) ( )) { b = f(23); // b = 23 * 4 = 92 void funz2 (int a) { return 4 * a; Esempio: float (*fp[5]) (int a); /*array di 5 puntatori a funzione che restituiscono un float e che utilizzano un parametro intero*/ Con i puntatori a funzione si puo realizzare una tabella di puntatori a funzione e chiamare una funzione in base all'indice della tabella. Il codice puo "scegliere" quale funzione chiamare in base ad un valore numerico intero direttamente, senza usare un lungo elenco di if o un enorme switch (e' una possibilita' molto usata dai compilatori stessi) 27 28

8 Confronto reference(riferimenti) e puntatori Confronto reference(riferimenti) e puntatori int b = 5; float f = 0.1; int* pb = &b; int& bref = b; float& ff = f; // si crea un puntatore a intero che punta a b // si crea una variabile alias di b // si crea una variabile alias di f cout << b = " << b << endl; //stampa b = 5 cout << pb = " << pb << endl; // stampa indirizzo di b cout << "Assegnamento a pb..." << endl; *pb = 8; cout << b = " << b << endl; // stampa b = 8 cout << bref = " << bref << endl; // stampa bref = 8 cout << "Assegnamento a b..." << endl; b = 15; // oppure bref = 15; cout << b = " << b << endl; // stampa b = 15 cout << bref = " << bref << endl; // stampa bref = Confronto reference(riferimenti) e puntatori Funzioni con parametri reference(riferimenti) e puntatori 31 dopo l'inizializzazione, un riferimento non puo piu essere associato ad un nuovo oggetto: ogni assegnamento al riferimento si traduce in un assegnamento all'oggetto riferito (sono alias). Un riferimento puo` essere inizializzato anche tramite un puntatore: int a = 5; int* pint = &a; int& aref = *pint; // aref è un alias di a tramite pint 32 il passaggio di parametri per indirizzo puo avenire con due metodi : reference e puntatori // metodo per reference (riferimento) swap (num1, num2); void swap (int& a, int& b) { int comodo; comodo = a; a = b; b = comodo;

9 Funzioni con parametri reference(riferimenti) e puntatori Confronto reference e puntatori // metodo per puntatori swap (&num1, &num2); void swap (int* a, int* b) { int * comodo; *comodo = *a; *a = *b; *b = comodo; Vantaggio reference : nella chiamata di una funzione non c'e` differenza tra passaggio per valore o per riferimento e` possibile cambiare meccanismo senza dover modificare ne` il codice che chiama la funzione ne` il corpo della funzione stessa; il codice è piu leggibile Svantaggio reference : il meccanismo dei reference nasconde all'utente il fatto che si passa un indirizzo e non una copia, e cio` puo` creare grossi problemi in fase di debugging del programma Vantaggio puntatori: i puntatori consentono un maggior controllo sugli accessi (tramite la keyword const per impedire la modifica) e rendono esplicito il modo in cui il parametro viene passato (nel 2. modulo vedremo che in alcuni casi è piu conveniente usare i reference per rendere piu leggibile il codice) Principale utilizzo dei puntatori Gestione della memoria I puntatori sono utilizzati sostanzialmente per quattro scopi: 1. Realizzazione di strutture dati dinamiche (es. liste linkate); dopo 2. Realizzazione di funzioni con effetti laterali sui parametri attuali; 3. Ottimizzare il passaggio di parametri di grosse dimensioni; 4. Rendere possibile il passaggio di parametri di tipo funzione. A ciascun programma utente viene assegnata una porzione di memoria, che è automaticamente divisa in quattro porzioni: area del codice contiene il codice del programma area statica che contiene le variabili globali e statiche Il primo caso e` tipico di applicazioni per le quali non e` noto a priori la quantita` di dati che si andranno a manipolare. Dichiarando un array si pone un limite massimo al numero di oggetti di un certo tipo immediatamente disponibili. Utilizzando i puntatori invece e` possibile realizzare ad esempio una lista il cui numero massimo di elementi non e` definito a priori. (p.e. anagrafe comune bari) area heap disponibile per allocazioni dinamiche area stack contiene i record di attivazione delle funzioni (variabili locali e parametri)

10 Mappa della memoria Gestione della memoria Area Dati Area Programma Area Statica Heap Le dimensioni delle aree Programma e Statica sono fisse e sono decise in fase di compilazione. Tali dimensioni corrispondono al numero di righe in linguaggio macchina del programma e al numero di variabili globali/statiche definite in esso. Le altre due aree (Heap e Stack) non hanno dimensione fissa. Tale dimensione varia nel tempo a seconda dell utilizzo delle due aree. In particolare per quanto riguarda l area Heap, essa crescerà quando verranno allocate variabili dinamiche. La sua dimensione si ridurrà, invece, quando una o più variabili dinamiche verranno deallocate. Stack Area di stack Area Heap L'area di memoria Stack (pila) é caratterizzata dalla proprietà che l'ultimo dato che entra in memoria nella fase di scrittura è il primo ad uscire nella fase di lettura (LIFO = Last In First Out). Appena l esecuzione passa dal programma chiamante a una funzione viene allocato nello Stack un pacchetto di dati (record di attivazione). Il record di attivazione contiene l'indirizzo di rientro nel programma chiamante e la lista degli argomenti passati alla funzione. Esso viene accatastato sopra il pacchetto precedente (quello del programma chiamante) e poi automaticamente rimosso dalla memoria appena l'esecuzione della funzione é terminata. Nella memoria stack vengono memorizzate anche altre informazioni, e precisamente i dati relativi a tutte le variabili automatiche (cioè locali e non statiche) create dalla funzione. Il loro tempo di vita é legato all'esecuzione della funzione proprio perché, quando la funzione termina, l'intera area stack allocata viene rimossa. L area Heap è soggetta a regole di visibilità e tempo di vita completamente diverse da quelle che governano l'area Stack e precisamente: l'area heap non é allocata automaticamente, ma può essere allocata o rimossa solo su esplicita richiesta del programma (allocazione dinamica della memoria); l'area allocata non é identificata da un nome, ma é accessibile esclusivamente tramite la definizione di un puntatore; la sua visibilità é legata a quella della variabile puntatore che contiene il suo indirizzo; il suo tempo di vita coincide con l'intera durata del programma, a meno che non venga esplicitamente deallocata; se il puntatore va in una particolare condizione, denominata out of scope, l'area non é più accessibile, ma continua a occupare memoria inutilmente

11 Gestione dinamica della memoria (operatore new) Gestione dinamica della memoria (operatore new) Operatore new Per allocare in modo dinamico la memoria il C++ mette a disposizione l'operatore new. Questo operatore costruisce uno o più oggetti nell'area heap e ne restituisce l'indirizzo. In caso di errore (memoria non disponibile) restituisce NULL occorre controllare l allocazione dello spazio di memoria. La sintassi dell'operatore new è: new tipo[dimensione] (valore_iniziale) tipo é il tipo dell'oggetto (o degli oggetti) da creare; dimensione é il numero degli oggetti, che vengono sistemati nella memoria heap consecutivamente (come gli elementi di un array); se questo operando é omesso, viene costruito un solo oggetto; se é presente, l'indirizzo restituito da new punta al primo oggetto dell array; valore_iniziale é il valore con cui l'area allocata viene inizializzata (deve essere di un tipo coerente); se é omesso l'area non é inizializzata. N.B.: dei tre operandi dell'istruzione solo il primo è obbligatorio Operatore new (esempi) Operatore new (esempi) Esempi : int* pint = new int; si alloca un oggetto int nell'area heap e si usa il suo indirizzo per inizializzare il puntatore pint int* parr = new int [10]; // allocazione di un array si allocano 10 oggetti int nell'area heap e si usa l'indirizzo del primo oggetto per inizializzare il puntatore parr Esempi : struct persona { int a; string b; ; persona* p_pers; p_pers = new persona[100] + 20; // allocazione di una tabella int* pmat = new int[20][20]; // allocazione di una matrice si alloca una matrice 20x20 di interi nell area heap e si usa l indirizzo del primo oggetto [0][0] per inizializzare il puntatore pmat In tal caso si definisce la struttura persona e si dichiara il puntatore p_pers a questa struttura al puntatore p_pers si assegna l'indirizzo del ventesimo dei cento oggetti di tipo persona, allocati nell'area heap 43 44

12 Gestione dinamica della memoria (operatore delete) Gestione della memoria Per deallocare la memoria dell'area heap in C++ mette a disposizione l'operatore delete Questo operatore non restituisce alcun valore Se l'operando punta a un'area in cui sono stati allocati più oggetti, delete va specificato con una coppia di parentesi quadre (senza la dimensione, che il C++ é in grado di riconoscere automaticamente). La sintassi dell'operatore delete è: delete nome_punt float* parr = new float [100] ; delete [ ] parr; // alloca 100 oggetti float // libera tutta la memoria allocata l'operatore delete non cancella la variabile nome_punt, né altera il suo contenuto: l'unico effetto é di liberare la memoria puntata rendendola disponibile per ulteriori allocazioni int* punt = new int; int a; punt = &a; // alloca un int nell'area heap /*assegna a punt un indirizzo dell'area stack (out of scope), per cui l'oggetto int dell'area heap non é più raggiungibile e deallocabile*/ Allocazione dinamica della memoria Gestione dell overflow di memoria La memoria heap non è infinita se ci si dimentica di usare l operatore delete e si ripete più volte l uso dell operatore new, si può avere out-ofmemory E necessario non lasciare che ciò avvenga deallocando le aree di memoria prima che si perdano i puntatori e diventino inaccessibili (operazione di garbage collection) Per gestire / trappare situazioni di errore di allocazione dinamica (p.e. mancanza di spazio nella memoria heap) set_new_handler( ) funzione che serve a gestire gli errori dell operatore new, la quale ha come parametro un puntatore a funzione. Pertanto quando si allocano degli oggetti con l operatore new, è necessario verificare che il puntatore restituito non è un puntatore nullo (NULL)

13 49 Esempio : Gestione dell overflow di memoria #include <iostream> #include <new> using namespace std; void mem_fault( ); set_new_handler (mem_fault); long dim; int* pmem; int blocco; cout << Quanta memoria? ; cin>> dim; for (blocco = 1; ; blocco++) { pmem = new int(dim); cout<< Alloc. blocco: <<blocco<<endl; void mem_fault( ) { cout<< Fault memoria << endl; exit(1); 50 Riepilogo della lezione Puntatori e gestione della memoria Puntatori Corretto uso dei puntatori (aritmetica dei puntatori) Confronto tra reference e puntatori Gestione della memoria Allocazione dinamica della memoria in C++ Gestione overflow memoria in C++ Fine della lezione Domande? 51