Puntatori e Memoria dinamica

INFORMATICA
Puntatori e
memoria dinamica
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 */
© Piero Demichelis
2
Puntatori: esempio
Indirizzi
int x=5, *px;
…
px = &x;
x
5
10016
px
10016
28104
dopo quel frammento di programma
px contiene l’indirizzo di x (cioè 10016).
Pertanto x e *px sono la stessa
cosa!
Memoria
© Piero Demichelis
3
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
© Piero Demichelis
4
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.
© Piero Demichelis
5
Puntatori
• Esempio:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a, *aptr;
a = 256;
aptr = &a;
printf (“\nL'indirizzo di a è %p", &a);
printf ("\nIl valore di aptr è %p", aptr);
/* indirizzo di a */
/* 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 */
}
© Piero Demichelis
6
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 */
© Piero Demichelis
7
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
© Piero Demichelis
8
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.
© Piero Demichelis
9
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
© Piero Demichelis
10
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
© Piero Demichelis
11
Aritmetica dei puntatori: Esempi
long *p1, *p2;
int j;
char *p3;
p2 = p1 + 4;
j = p2 - p1;
j = p1 - p2;
p1 = p2 - 2;
p3 = p1 - 1;
j = p1 - p3;
/* legittimo: p2 = p1 + (4*sizeof(long)) */
/* a j viene assegnato 4 */
/* a j viene assegnato  4 */
/* OK, i tipi dei puntatori sono compatibili */
/* NO i tipi dei puntatori sono diversi */
/* NO i tipi dei puntatori sono diversi */
• NOTA: l’aritmetica dei puntatori dipende dalla macchina
- Quanti byte occupa un puntatore?
- TurboC  puntatore = 2 byte
© Piero Demichelis
12
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]).
aptr
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
.....
aptr = a
.....
a
© Piero Demichelis
13
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
© Piero Demichelis
14
Puntatori e vettori: analogie
• 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.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[5], *a_ptr;
int i;
© Piero Demichelis
15
Puntatori e vettori: analogie
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));
}
© Piero Demichelis
16
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”;
1000
1001
1002
1003
1004
‘a’
‘b’
‘c’
‘d’
‘\0’
s
2200
2201
...
6400
6400
6401
6402
6403
6405
‘a’
‘b’
‘c’
‘d’
‘\0’
© Piero Demichelis
p
17
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;
© Piero Demichelis
18
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.
© Piero Demichelis
19
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;
}
© Piero Demichelis
20
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.
© Piero Demichelis
21
Gestione della memoria
• 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.
© Piero Demichelis
22
Gestione della memoria
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.
© Piero Demichelis
23
Gestione della memoria
• 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.
© Piero Demichelis
24
Gestione della memoria
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.
© Piero Demichelis
25
Gestione della memoria
• 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!
© Piero Demichelis
26
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.
ptr1
record 1
ptr2
record 2
ecc.
© Piero Demichelis
27
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.
© Piero Demichelis
28
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.
© Piero Demichelis
29
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)
sizeof (long int)
short s; ...sizeof (s)
short s; ...sizeof (s + 24)
1
4
2
2
(il risultato dell’addizione è di tipo int) !
long int vett[10]; ...sizeof (vett)
double num_real; ... sizeof (num_real)
double vett_r [20]; ... sizeof (vett_r)
© Piero Demichelis
40
8
160
30
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) );
}
© Piero Demichelis
31
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.
© Piero Demichelis
32
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.
© Piero Demichelis
33
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>.
© Piero Demichelis
34
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.
© Piero Demichelis
35
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);
…
© Piero Demichelis
36
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.
© Piero Demichelis
37
Memoria dinamica
#include <stdio.h>
#include <stdlib.h>
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));
© Piero Demichelis
38
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]);
© Piero Demichelis
39
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));
}
© Piero Demichelis
40
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.
© Piero Demichelis
41
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
8
Juventus 66
Milan 62
Inter 60
Roma 58
Bologna 56
Livorno 54
Reggina 52
Siena 50
© Piero Demichelis
42
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)
© Piero Demichelis
43
Esempio
main()
{
typedef struct
{
char nome_sq[30];
int punti;
} classifica;
classifica *vett_class;
char nomefile[30];
int num_squadre, i;
/* puntatore alla struttura
*/
FILE *filedati;
© Piero Demichelis
44
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));
© Piero Demichelis
45
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);
}
© Piero Demichelis
46
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.
© Piero Demichelis
47
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
© Piero Demichelis
48
Strutture dati complesse
• 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;
}
© Piero Demichelis
49
Strutture dati complesse
• 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 punt
testa
dato 2 punt
dato 3 punt
dato n-1 punt
© Piero Demichelis
dato n NULL
50
Strutture dati complesse
• 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.
© Piero Demichelis
51
Strutture dati complesse
• Ad esempio pensando a una struct con due campi
puntatori potremo costruire un albero di questo tipo:
p1
d1
d2
d4
p7
p8
p2
d3
p3 p4
d5
p9 p10
p5
p6
d6 p11 p12
d7 p13 p14
ecc.
© Piero Demichelis
52