informatica puntatori e memoria dinamica

INFORMATICA

Puntatori ememoria dinamica

2 © Piero Demichelis

Puntatori

• I puntatori sono variabili che contengono indirizzi di memoria.

• Sono specificati tramite l’operatore unario ‘*’ specificato accanto al nome della variabile.

• Sintassi:

<tipo> ‘*’ <identificatore>

• Per ogni tipo di variabile “puntata ”, esiste un “tipo ” diverso di puntatore: Esempi:

int x; int *px; /* puntatore a un intero breve */

double y; double *py; /* puntatore a un double */


Puntatori: esempio

int x=5, *px;…px = &x;

dopo quel frammento di programmapx contiene l’indirizzo di x (cioè 10016).

Pertanto x e *px sono la stessa cosa!

Memoria

5x

px

Indirizzi

10016

2810410016


Puntatori

• Gli operatori ‘*’ e ‘&’ sono uno l’inverso dell’altro L’applicazione consecutiva in qualunque ordine ad un

puntatore fornisce lo stesso risultato• *&px e &*px sono la stessa cosa!

• In termini di operatori: ‘*’= operatore di indirezione

• Opera su un indirizzo • Ritorna il valore contenuto in quell’indirizzo

‘&’ = operatore di indirizzo• Opera su una variabile• Ritorna l’indirizzo di una variabile

• Quindi:*(&px): il contenuto della cella che contiene l’indirizzo di px&(*px): l’indirizzo della variabile puntata da px


Puntatori

• Nelle istruzioni di I/O per i puntatori è definito un apposito descrittore di campo, %p, il quale converte in un intero esadecimale la variabile a cui è riferito.

• Questo descrittore può essere usato sia con la scanf che con la printf, tuttavia la sua utilità in input è riservata a casi particolarissimi di accesso diretto a specifiche locazioni di memoria.

• In output invece può essere utilizzato per visualizzare l’indirizzo di memoria delle variabili.


Puntatori• Esempio:

#include <stdio.h>#include <stdlib.h>

int main(){int a, *aptr;a = 256;aptr = &a;

printf (“\nL'indirizzo di a è %p", &a); /* indirizzo di a */printf ("\nIl valore di aptr è %p", aptr); /* indirizzo di a */

printf ("\nIl valore di a è %p", a); /* valore di a in Hex. */printf ("\nIl valore di *aptr è %p", *aptr); /* valore di a in Hex*/printf ("\n&*aptr = %p ----- *&aptr = %p", &*aptr, *&aptr); /* indirizzo di a */}


Operazioni sui puntatori

• Sui puntatori sono definite solo alcune operazioni:

Incremento/decremento

int *px;px++; px--; /* sono operazioni lecite */

Somma/sottrazione di un valore intero

int *px px += 3; px -= 5; /* sono operazioni lecite */

Assegnazione di un puntatore ad un altro dello stesso tipo

int *px, *py; px = py; /* è un operazione lecita */


Operazioni sui puntatori

Sottrazione tra due puntatori (NON la somma) dello stesso tipo

double *px, *py; px – py /* è un operazione lecita e produce un

risultato intero (quanti elementi ci sono tra i due indirizzi) */

Confronto tra puntatori dello stesso tipo

int *px, *py;

px == py px != py px > py /* sono operazione lecite */

• Confronto tipico:

px == NULL


Operazioni sui puntatori: errori tipici

• L’assegnazione di un valore a un puntatore è permessa, ma è sconsigliata.

int *px;px = 5; /* L’accesso a quella cella potrebbe essere

vietato! */

• Sottrarre o confrontare puntatori di tipo diverso.

Unica eccezione: uso di puntatori void* che sono considerati come dei puntatori “jolly”.

• Usare l’aritmetica dei puntatori su puntatori che non si riferiscono ad un vettore.

Gli operatori relazionali (<,>, etc.) hanno senso solo se riferiti ad un “oggetto” comune.


Aritmetica dei puntatori

• Le operazioni sui puntatori non avvengono secondo l’aritmetica intera ma dipendono dal tipo a cui si fa riferimento.

• Incremento/decremento di un puntatore: Il risultato è ottenuto moltiplicando il valore

dell’incremento o decremento per la dimensione (numero di byte) del tipo cui si fa riferimento.

Esempio:int *px;/* assumiamo che px sia uguale a 1000 */px += 3; px non vale 1003, bensì:

1000 + 3*sizeof(int) = 1006


Aritmetica dei puntatori

• Sottrazione tra puntatori: Il risultato corrisponde al numero di elementi del tipo cui

si fa riferimento compresi tra i due puntatori.

Esempio:

int *px, *py, diff;

/* assumiamo che px sia uguale a 1012 e py uguale a 1000 */

diff = px – py;diff non vale 12, bensì:

(1012-1000)/sizeof(int) = 6


Aritmetica dei puntatori: Esempi

long *p1, *p2;int j;char *p3;

p2 = p1 + 4; /* legittimo: p2 = p1 + (4*sizeof(long)) */j = p2 - p1; /* a j viene assegnato 4 */j = p1 - p2; /* a j viene assegnato 4 */p1 = p2 - 2; /* OK, i tipi dei puntatori sono compatibili */p3 = p1 - 1; /* NO i tipi dei puntatori sono diversi */j = p1 - p3; /* NO i tipi dei puntatori sono diversi */

• NOTA: l’aritmetica dei puntatori dipende dalla macchina Quanti byte occupa un puntatore? TurboC puntatore = 2 byte


Puntatori e vettori

• La relazione tra puntatori e vettori in C è molto stretta.

• Il nome di un vettore rappresenta l’indirizzo del primo elemento del vettore stesso! Esempio:

• int a[8], *aptr;• L’assegnazione aptr = a; fa puntare aptr al primo

elemento del vettore a (cioè a[0]).a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]aptr

aaptr = a

..........


Puntatori e vettori: analogie

• L’analogia tra puntatori e vettori si basa sul fatto che, dato un vettore a[ ]

a[i] e *(aptr+i) sono la stessa cosa!

• Pertanto ci sono almeno due modi per accedere al generico elemento i del vettore:

Usando il nome del vettore (tramite indice) Usando un puntatore (tramite scostamento o offset)

• Interpretazione: aptr + i = indirizzo dell’elemento che si trova i posizioni

dall’inizio *(aptr + i) = contenuto di questo elemento



• Esempio: il programma che segue riempie un vettore di 5 elementi leggendone i valori da tastiera e successivamente lo visualizza due volte; la prima in modo tradizionale, la seconda utilizzando un puntatore a_ptr.


int main(){int a[5], *a_ptr;int i;



for (i = 0; i < 5; i++) { /* legge i valori da inserire nel vettore */ printf ("\nInserisci a[%d] = ", i); scanf ("%d", &a[i]); }/* visualizza il vettore */for (i = 0; i < 5; i++) /* in modo “normale” */ printf ("\nValore di a[%d] = %d", i, a[i]);

a_ptr = a;for (i = 0; i < 5; i++) /* utilizzando un puntatore (modo A) */ printf ("\nValore di a[%d] = %d", i, a_ptr[i]);

for (i = 0; i < 5; i++) /* utilizzando un puntatore (modo B) */ printf ("\nValore di a[%d] = %d", i, *(a_ptr+i));}


Puntatori e stringhe

• Stringa è un vettore di char terminato da ’\0‘.• La relazione tra puntatori e stringhe è

sostanzialmente identica a quella con vettori generici.

• Differenza: char *p = “abcd”; char s[5] = “abcd”;

‘a’‘b’‘c’‘d’‘\0’

s10001001100210031004

p22002201...

64006401640264036405

6400

‘a’‘b’‘c’‘d’‘\0’


Puntatori e struct

• Il C fornisce uno speciale operatore ( l’operatore freccia: ->) per accedere ai membri di una struttura tramite un puntatore alla struttura stessa:

Utile per passaggio di struct per indirizzo!

• Esempio:

struct complex {

double re; double im; } complesso, *pc;


Puntatori e struct

• Come abbiamo visto a suo tempo si accede ai campi con

complesso.re, complesso.im

• Utilizzando il puntatore alla struttura, agli stessi campi si accede con

pc->re, pc->im

naturalmente dopo aver assegnato l’indirizzo di complesso a pc!

pc = &complesso;

• NOTA: come già detto a proposito dei vettori, pc->re e (*pc).re sono equivalenti.


Puntatori e struct: Esempio

struct complex {

double re; double im; };

typedef struct complex complesso;

/* Funzione add_cplx: somma due numeri complessi: a = b + c */

void add_cplx (complesso *a, complesso *b, complesso *c) {

a->re = b->re + c->re;a->im = b->im + c->im;

}


Gestione della memoria

• Fino ad ora abbiamo sempre dichiarato variabili di dimensioni note, e la cui durata in vita è vincolata alle regole di esecuzione di un programma scritto in linguaggio C.

• Ad esempio una variabile dichiarata nel main vive per tutta la durata del programma; una variabile dichiarata in una funzione vive solo per la durata dell’esecuzione della funzione, se la funzione viene richiamata un’altra volta la stessa variabile di prima viene creata di nuovo e vivrà solo per la durata di quell’esecuzione.

• Le variabili così definite, siano esse variabili semplici oppure vettori oppure ancora altre strutture dati, si dicono variabili statiche.



• Per usare, ad esempio, un vettore, è necessario specificarne la dimensione in fase di definizione.

• La dichiarazione, per esempio,

int peso [100];

• alloca un vettore di cento interi, che, a seconda di dove avviene la definizione, vive per la durata della funzione in cui viene definito (variabile automatica) o per tutta la durata del programma.

• Questo implica che si conosca in anticipo e con precisione, (a compile-time, si dice, o in pratica quando si scrive il programma) il numero dei dati da trattare.



E se invece non se ne conosce la dimensione?

• In pratica si ricorre alla sovra-allocazione : si dimensiona la variabile (ovvero il vettore) in maniera tale da contenere il più grande numero immaginabile di dati in ingresso.

• Esempio #1: acquisendo linee di testo da tastiera, si può ipotizzare (ma è un ipotesi come un'altra!) che le linee non superino mai i 100 caratteri.

• E se una linea supera quel limite? Si può al più mandare un messaggio d'errore all'utente ma gestire quell’errore all’interno del programma è quasi sempre complicato.



• Esempio #2: si supponga di dover leggere e registrare in memoria (ad esempio, in un vettore) dati da un file di dimensioni ignote; si può ipotizzare (ma è un ipotesi come un'altra!) che i dati non superino un numero molto grande, per esempio un milione.

• Questo caso è ancora più grave di quello prospettato nell’esempio #1, in quanto questa situazione anomala non è praticamente mai gestibile nel programma e anche l’eventuale segnalazione all’utente del problema non conduce a nessuna contromisura efficace.

• Certo, si possono scrivere messaggi di errore a schermo, ma di fatto è un fallimento del programma di fronte a dati

perfettamente legittimi.



Cosa si può fare?

• Per risolvere il problema molti linguaggi ad alto livello consentono di allocare memoria secondo il bisogno che emerge al momento dell'esecuzione del programma.

• Questa opportunità è nota col nome di

allocazione dinamica della memoria

• La dimensione della variabile viene decisa a run-time (cioè, al momento dell'esecuzione del programma) a seconda del numero di dati in ingresso.



• Esempio: leggendo dei record da un file posso richiedere, prima di ogni lettura, l’allocazione di uno spazio di memoria grande a sufficienza per contenere i dati che leggerò.

…while (!feof(fp)) { alloca memoria per un record; fscanf (fp, …); /* leggi il record */ … }

• Ad ogni ciclo si incrementa lo spazio di memoria riservato alla mia base dati!


Memoria dinamica

• Come funziona il meccanismo? Tramite puntatori! Ogni volta che richiedo una nuova area di memoria mi viene restituito un puntatore all’area di memoria che mi è stata assegnata.

ecc.

ptr1record 1

record 2ptr2


Memoria dinamica

• Resta ancora da definire quanto grande deve essere lo spazio di memoria che deve essere richiesto.

• Dal momento che tutti gli oggetti di un certo tipo occupano esattamente lo stesso spazio di memoria, possiamo determinare con precisione lo spazio di memoria (il numero di byte) necessario a ospitare i dati.

• Per conoscerne con precisione la quantità basta usare l'operatore sizeof il quale restituisce il numero di byte che occupa il tipo di dato, o la struttura dati, indicata quale parametro tra le parentesi.


Memoria dinamica

• L'operatore sizeof può agire o su un tipo, ad esempio,

sizeof (double)

o su una variabile, un vettore, un’espressione, una struct, ad esempio,

sizeof (vettore_dati)

in ogni caso restituisce un intero corrispondente al numero di byte occupato dall’argomento. Per definizione, sizeof applicato al tipo char restituisce 1.

• Non può essere applicato a vettori incompleti (senza indicazione della dimensione), a funzioni, o al tipo void.


Memoria dinamica

• Ecco alcuni esempi di applicazione di sizeof nell’ipotesi che gli oggetti di tipo short occupino 2 byte e quelli di tipo long 4 byte.

sizeof (char) 1 sizeof (long int) 4short s; ...sizeof (s) 2short s; ...sizeof (s + 24) 2 (il risultato dell’addizione è di tipo int) !long int vett[10]; ...sizeof (vett) 40double num_real; ... sizeof (num_real) 8double vett_r [20]; ... sizeof (vett_r) 160


Memoria dinamica

• Programma di esempio per determinare le dimensioni dei principali tipi di dati C:

#include <stdio.h>

int main() {printf ("\t Dimensione dei tipi:\n");printf ("char \t short \t int \t long \t float \t double \n");printf ("%3d \t %3d \t %3d \t %3d \t %3d \t %3d\n", sizeof (char), sizeof (short), sizeof (int), sizeof (long), sizeof (float), sizeof

(double) );}


Memoria dinamica

• Quando sizeof è applicato ad un' espressione, l'espressione è analizzata al momento della compilazione per determinare lo spazio occupato, ma non è valutata.

• Per esempio, l'esecuzione di:

sizeof (j++)

non provocherà l’incremento di j, ma verrà valutata solamente la dimensione in byte del risultato.


Memoria dinamica

• Per ottenere l’allocazione di spazio in memoria sono disponibili delle funzioni di libreria.

• Permettono ad un programma di richiedere anche ripetutamente l'allocazione di una regione “fresca ” di memoria e di deallocarla più tardi (liberarla) se tale regione non serve più.

• Regioni esplicitamente deallocate sono riciclate dallo storage manager del sistema operativo per soddisfare ulteriori richieste del programma corrente o di un qualunque altro programma che faccia richiesta di allocazione di memoria.


Memoria dinamica

• Quando un programma richiede l’allocazione di un certo spazio di memoria, il sistema verifica l’esistenza di uno spazio di celle contigue disponibile pari a quello richiesto e, se lo trova, lo occupa e ne restituisce l’indirizzo al chiamante (puntatore alla memoria).

• Questo puntatore sarà di tipo void *, ma è garantito che sia adeguatamente allineato per qualsiasi tipo di dati. E’ necessario che il chiamante faccia un cast per convertirlo nell’opportuno tipo di puntatore (int, double, ecc.).

• Le funzioni sono dichiarate nell'header file <stdlib.h>.


Funzione malloc

• La creazione di una variabile dinamica avviene prelevando dalla memoria un blocco di dimensione opportuna tramite una funzione di allocazione (malloc).

• Prototipo della funzione:

void *malloc (unsigned int dimensione);

• La funzione restituisce un puntatore a void (puntatore a memoria non strutturata) oppure il valore NULL se l'operazione di allocazione non ha avuto successo (ad esempio per mancanza di memoria disponibile).

• Per utilizzare correttamente l'area allocata occorre effettuare un'operazione di cast del puntatore verso il tipo di dato a cui l’area è destinata.


Funzione malloc

• Esempio:

…int dimension = 50;char *stringa;…stringa = (char *) malloc (dimension * sizeof (char));if (stringa == NULL) { printf ( “\nErrore: memoria non disponibile”); return ; }strcpy (stringa, “questa e’ una stringa”);printf (“\n%s”, stringa);…


Memoria dinamica

• Una prima soluzione al problema della definizione della lunghezza dei vettori ignota al momento della scrittura del programma può pertanto trovare soluzione, purché l’utente sia in grado di fornirla all’avvio del programma.

• Esempio: programma che richiede il numero di elementi interi da leggere, alloca lo spazio in memoria, legge gli elementi e infine li visualizza.

• Simile a: programma che richiede il numero di elementi interi da leggere, li legge e li salva in un vettore e infine li visualizza.


Memoria dinamica


int main(){int *punt, i, num_el;

/* richiede il numero di elementi del vettore */printf ("\nNumero di elementi da leggere: ");scanf ("%d", &num_el);

/* richiede l’allocazione di memoria sufficiente a contenere i dati pari a num_el * il numero di byte occupato da ogni elemento */

punt = (int *) malloc (num_el * sizeof (int));


Memoria dinamica

if (punt == NULL) { printf ( “\nErrore: memoria non disponibile”); return; }/* legge num_el elementi da tastiera e li salva nello spazio

allocato */for (i = 0; i < num_el; i++) { printf ("\nInserisci l'elemento di indice %d = ", i); scanf ("%d", &punt[i]); }/* visualizza il vettore */for (i = 0; i < num_el; i++) printf ("\nElemento %d = %d", i, punt[i]);


Memoria dinamica

/* Utilizzando la definizione di puntatore la lettura e visualizzazione dei dati può essere effettuata anche nel modo seguente */

/* legge num_el elementi da tastiera e li salva nello spazio allocato */

for (i = 0; i < num_el; i++) { printf ("\nInserisci l'elemento di indice %d = ", i); scanf ("%d", (punt + i)); }/* visualizza il vettore */for (i = 0; i < num_el; i++) printf ("\nElemento %d = %d", i, *(punt + i));

}


Funzione free

• Per liberare la memoria allocata dinamicamente, si utilizza la funzione free.

• Il blocco di memoria deallocato viene restituito allo storage manager del sistema operativo e potrà essere riutilizzato successivamente dai programmi che faranno richiesta di memoria.

• Prototipo:void free (void *punt)

• il parametro della funzione è il puntatore all’area di memoria allocata in precedenza tramite malloc.


Esempio

• Si realizzi un programma che legga da un file la classifica di un campionato di calcio. Il numero di squadre è scritto nella prima riga del file.

• Successivamente il programma dovrà visualizzare la classifica sul monitor.

• Esempio del file di input

8Juventus 66Milan 62Inter 60Roma 58Bologna 56Livorno 54Reggina 52Siena 50


Esempio

• Analisi:

per memorizzare le squadre e il relativo punteggio useremo una struct con due campi: nome della squadra (stringa) e punti (int).

Il programma dovrà richiedere il nome del file, aprirlo e leggere il primo valore, ovvero il numero di squadre che seguono.

In base a questo numero richiederà l’allocazione del numero di byte necessario per memorizzare l’intero file ovvero tutte le squadre e il loro punteggio.

Il numero di byte da richiedere sarà uguale a:num. squadre * sizeof (struttura con i due campi)


Esempio

main(){

typedef struct { char nome_sq[30]; int punti; } classifica;

classifica *vett_class; /* puntatore alla struttura */

char nomefile[30]; int num_squadre, i;

FILE *filedati;


Esempio

/* richiede il nome del file contenente la classifica */printf ("\nIntroduci il nome del file: ");scanf ("%s", nomefile);/* apre il file */if ((filedati = fopen (nomefile,"r")) == NULL) {

printf (“\nErrore apertura: %s", nomefile); exit (0);

}

/* legge il primo dato, ovvero il numero di squadre che seguono */

fscanf (filedati, "%d", &num_squadre);

/* richiede l’allocazione della memoria necessaria per memorizzare il resto del file */

vett_class = (classifica *) malloc (num_squadre * sizeof (classifica));


Esempio

if (vett_class == NULL) { printf (“\nErrore allocazione memoria"); exit (1); }/* legge il file e lo memorizza nel vettore dinamico */for (i = 0 ; i < num_squadre ; i++) fscanf (filedati, "%s%d", &vett_class[i].nome_sq,

&vett_class[i].punti);fclose (filedati);/* Visualizza sul monitor il vettore dinamico */printf ("\n\nSquadra Punti\n");for (i = 0; i < num_squadre; i++) printf(“\n%-12s %d", vett_class[i].nome_sq, vett_class[i].punti);/* rilascia la memoria */free (vett_class);}


Memoria dinamica

• Spesso succede però che la quantità di memoria necessaria per memorizzare i dati non è nota neppure nel momento in cui inizia l’esecuzione del programma.

• Tuttavia la quantità di memoria che un programma può allocare dipende solo dalla memoria disponibile.

• Per risolvere definitivamente il problema bisogna pensare di costruire strutture dati che “crescono” durante l’esecuzione del programma e quindi capaci di adattarsi alle necessità man mano che queste emergono.


Strutture dati complesse

• Mettendo insieme la versatilità delle struct e la possibilità di richiedere quanta memoria si desidera (nell’ambito della memoria disponibile) si riesce a costruire delle strutture dati assai flessibili e complesse.

• Non essendoci particolari limiti alla definizione di un campo di una struct possiamo pensare di definirlo di tipo puntatore, in particolare puntatore a una struct dello stesso tipo.

• Se in quel campo inseriamo l’indirizzo di un’altra struttura possiamo creare una struttura dati, nota come lista concatenata, simile a un vettore e che può crescere al bisogno fino al limite della memoria disponibile



• Supponiamo ad esempio di dover leggere da un file una sequenza di numeri interi la cui dimensione non è nota al momento della scrittura del programma.

• Si potrebbe pensare a una lista concatenata utilizzando una struct con due campi: un campo int per il valore letto dal file e un campo puntatore per concatenarsi al valore successivo.

• La struct sarà del tipo:

struct { int dato; void *punt; }



• Ad ogni lettura dal file scriveremo il valore del dato nel primo campo (quello int) utilizzando poi il campo puntatore per inserire l’indirizzo della prossima area di tipo struct che richiederemo con la malloc e destinata a contenere il prossimo dato.

• Si ottiene una struttura di questo tipo:

dato 1 dato 2 dato 3

dato n-1 dato ntesta

punt punt punt

punt NULL



• La lista concatenata è una struttura sequenziale: per leggere l’ennesimo dato bisogna scorrere gli n-1 dati che precedono.

• La lunghezza della lista è limitata solo dalla memoria a disposizione.

• Poiché non c’è limite al numero di campi di una struttura, si può pensare a tutta una serie di strutture dati in cui l’unico limite è la fantasia del programmatore.

• Naturalmente esistono delle strutture dati “canoniche” che vengono regolarmente utilizzate nei programmi e che si chiamano stack, code, alberi, ecc.



• Ad esempio pensando a una struct con due campi puntatori potremo costruire un albero di questo tipo:

d1

d2 d3

d4 d5 d6 d7

p1 p2

p3 p4 p5 p6

p7 p8 p9 p10 p11 p12 p13 p14

ecc.

informatica puntatori e memoria dinamica

Documents