Finora abbiamo lavorato con variabili e array la cui dimensione doveva essere nota al momento della scrittura del programma (o determinata automaticamente all’ingresso di una funzione) e il cui ciclo di vita era rigidamente legato al blocco di codice in cui venivano dichiarati. Nei programmi reali, tuttavia, molto spesso non conosciamo a priori quanti dati dovremo elaborare: il numero di record di un file, la dimensione di una matrice letta da input o i nodi di una struttura dati che cresce e si riduce durante l’esecuzione.
L’allocazione dinamica della memoria risolve questo problema permettendo al programma di richiedere e rilasciare blocchi di memoria a tempo di esecuzione (runtime), attingendo a una regione dedicata chiamata Heap.
Layout di memoria di un processo
Quando il sistema operativo avvia un programma compilato in C, gli assegna uno spazio di indirizzamento virtuale suddiviso in quattro segmenti principali, ciascuno con uno scopo e regole di gestione ben precise:
flowchart TD
subgraph Memoria["Spazio di Indirizzamento del Processo (Indirizzi crescenti dal basso verso l'alto)"]
direction TB
S["<b>Stack (Pila)</b><br/>Variabili locali (auto), parametri formali, indirizzi di ritorno.<br/><i>Cresce verso il basso ↓ — Gestione automatica LIFO</i>"]
FREE["<i>Spazio libero condiviso<br/>(Stack e Heap crescono l'uno verso l'altro)</i>"]
H["<b>Heap (Cumulo)</b><br/>Memoria allocata dinamicamente a runtime (malloc, calloc, realloc).<br/><i>Cresce verso l'alto ↑ — Gestione manuale del programmatore (free)</i>"]
BSS["<b>Segmento Data / BSS</b><br/>Variabili globali e variabili <code>static</code> (inizializzate in Data, non inizializzate in BSS).<br/><i>Dimensione fissa per tutta l'esecuzione</i>"]
T["<b>Segmento Text (Codice)</b><br/>Istruzioni macchina compilate del programma e costanti in sola lettura.<br/><i>Sola lettura (Read-Only)</i>"]
end
S --> FREE
H --> FREE
BSS --- H
T --- BSS
Confronto tra i segmenti di memoria
Segmento
Cosa contiene
Quando viene allocato/deallocato
Chi lo gestisce
Dimensione e velocità
Text (Code)
Istruzioni binarie eseguibili, stringhe letterali
All’avvio / alla terminazione del processo
Sistema Operativo / Loader
Fissa, sola lettura
Data / BSS
Variabili globali e static (Data se inizializzate, BSS azzerate di default)
All’avvio / alla terminazione del processo
Compilatore e Loader
Fissa, determinata a compile-time
Stack
Record di attivazione delle funzioni (variabili locali, parametri, return address)
All’ingresso e all’uscita di ogni funzione/blocco (politica LIFO)
Automaticamente dalla CPU (registro Stack Pointer)
Limitata (pochi MB), accesso estremamente veloce
Heap
Blocchi di memoria richiesti dinamicamente a runtime
Su richiesta esplicita (malloc/calloc) fino a free (o fine processo)
Manualmente dal programmatore tramite l’allocatore di libreria
Molto grande (limitata dalla RAM/swap), accesso leggermente più lento e soggetto a frammentazione
Variabile puntatore vs Blocco allocato
Quando scriviamo dentro una funzione:
int *p = (int *)malloc(10 * sizeof(int));
dobbiamo distinguere due entità che vivono in segmenti diversi:
La variabile puntatore p (4 o 8 byte che contengono un indirizzo) è una variabile locale e risiede nello Stack.
Il blocco di 10 interi a cui p punta (10×4=40 byte) risiede nello Heap.
La libreria <stdlib.h> per la gestione dello Heap
Tutte le funzioni standard per l’allocazione e la deallocazione dinamica sono dichiarate nell’header <stdlib.h>. Esse lavorano con il tipo puntatore generico void *, che in C può essere assegnato a qualsiasi tipo di puntatore a oggetto (es. int *, double *, struct Nodo *).
1. malloc (Memory Allocation)
void *malloc(size_t size);
Scopo: Alloca nello Heap un blocco contiguo di memoria di size byte.
Valore di ritorno: Restituisce l’indirizzo del primo byte del blocco allocato, oppure NULL se la memoria richiesta non è disponibile (esaurimento dello Heap).
Contenuto iniziale: La memoria allocata da mallocnon è inizializzata; contiene valori “spazzatura” (garbage), ovvero i bit lasciati da precedenti utilizzi di quelle celle di memoria.
Uso dell’operatore sizeof: Non bisogna mai inserire il numero di byte “a mano” (es. malloc(40)), perché la dimensione dei tipi primitivi varia tra architetture a 16, 32 e 64 bit. Si moltiplica sempre il numero di elementi n per sizeof(tipo):
Scopo: Alloca nello Heap spazio per un array di nmemb elementi, ciascuno di dimensione size byte (per un totale di nmemb×size byte contigui).
Differenza chiave rispetto a malloc: calloc riceve separatamente il numero di elementi e la dimensione di ciascuno e azzera tutti i bit del blocco. Tutti i bit a zero rappresentano zero per i tipi interi, mentre C11 non impone che rappresentino un puntatore nullo o uno zero in virgola mobile.
Valore di ritorno: Puntatore al blocco azzerato, oppure NULL in caso di fallimento.
/* Alloca un array di 100 interi già tutti inizializzati a 0 */int *contatori = (int *)calloc(100, sizeof(int));
3. realloc (Re-allocation)
void *realloc(void *ptr, size_t new_size);
Scopo: Ridimensiona (allarga o restringe) un blocco di memoria nello Heap precedentemente allocato da malloc, calloc o realloc e puntato da ptr, portandolo a new_size byte.
Come funziona sotto il cofano:
Allargamento in-place: Se subito dopo il blocco attuale nello Heap c’è spazio libero sufficiente, realloc estende il blocco sul posto e restituisce lo stesso indirizzo ptr. I byte aggiunti in coda non sono inizializzati.
Spostamento in una nuova area: Se non c’è spazio contiguo sufficiente, realloc alloca un nuovo blocco di dimensione new_size in un’altra zona dello Heap, copia automaticamente il contenuto del vecchio blocco nel nuovo, libera (free) automaticamente il vecchio blocco e restituisce il nuovo indirizzo.
Fallimento: Se non c’è memoria sufficiente nello Heap per soddisfare la richiesta, realloc restituisce NULL, ma NON libera il blocco originale puntato da ptr, che rimane valido e intatto!
Casi particolari standard:
Se ptr == NULL, realloc(NULL, new_size) si comporta esattamente come malloc(new_size).
Per una richiesta di dimensione zero, gestire esplicitamente il caso con free(ptr) se si vuole rilasciare il blocco. In C11 una richiesta zero ha comportamento dipendente dall’implementazione.
Uso sicuro di realloc con puntatore temporaneo
Non bisogna mai assegnare il risultato di realloc direttamente allo stesso puntatore:
/* PERICOLO! Se realloc fallisce e restituisce NULL, perdiamo l'indirizzo del vecchio blocco ancora allocato -> Memory Leak immediato! */p = realloc(p, nuova_dim * sizeof(int)); // SBAGLIATO!
Il pattern corretto utilizza sempre un puntatore temporaneo:
int *tmp = (int *)realloc(p, nuova_dim * sizeof(int));if (tmp == NULL) { /* Gestione dell'errore: p punta ancora ai vecchi dati validi! */ free(p); exit(EXIT_FAILURE);}p = tmp; /* Aggiorniamo p solo dopo aver verificato il successo */
4. free (Deallocazione)
void free(void *ptr);
Scopo: Restituisce all’allocatore dello Heap il blocco di memoria puntato da ptr, rendendolo nuovamente disponibile per future allocazioni.
Regole fondamentali:
ptr deve contenere esattamente l’indirizzo iniziale restituito da una precedente chiamata a malloc, calloc o realloc (non si può passare p + 2 o l’indirizzo di una variabile sullo Stack &x).
Se ptr == NULL, free(NULL) è un’operazione valida che non fa nulla (no-op).
Dopo free(ptr), la variabile ptr sullo Stack continua a contenere il vecchio indirizzo, che però ora punta a memoria non più nostra (dangling pointer). È buona norma impostare subito ptr = NULL;.
Allocazione dinamica di Array 1D e Matrici 2D
Array monodimensionali (1D)
Un array dinamico di N elementi di tipo T si alloca con un singolo puntatore T *v. Una volta allocato, grazie all’equivalenza tra array e puntatori (v[i] equivale a *(v + i)), si usa con la normale sintassi delle parentesi quadre.
Matrici bidimensionali (2D)
In C esistono due tecniche principali per allocare dinamicamente una matrice di R righe e C colonne:
Metodo A: Array di puntatori a righe (int **m)
Si alloca prima un vettore principale di R puntatori a intero (int *), e poi, con un ciclo, si alloca ciascuna delle R righe di C interi.
Vantaggi: Si accede agli elementi con la comoda sintassi doppia m[i][j]; le righe possono anche avere lunghezze diverse (ragged arrays) o essere scambiate in O(1) scambiando solo i due puntatori m[i] e m[k].
Svantaggi: Richiede R+1 chiamate a malloc e R+1 chiamate a free (in ordine inverso: prima le righe, poi il vettore dei puntatori); le righe non sono necessariamente contigue in memoria (peggiore località della cache).
/* Allocazione di una matrice R x C come array di puntatori */int **alloca_matrice(int R, int C) { int **m = (int **)malloc(R * sizeof(int *)); if (m == NULL) return NULL; for (int i = 0; i < R; i++) { m[i] = (int *)malloc(C * sizeof(int)); if (m[i] == NULL) { /* Rollback: liberiamo le righe già allocate prima di uscire! */ for (int k = 0; k < i; k++) { free(m[k]); } free(m); return NULL; } } return m;}/* Deallocazione corretta: PRIMA le singole righe, POI il vettore esterno */void libera_matrice(int **m, int R) { if (m == NULL) return; for (int i = 0; i < R; i++) { free(m[i]); } free(m);}
Metodo B: Blocco unico contiguo (int *m di dimensione R×C)
Si effettua una sola malloc di R×C elementi e si linearizzano gli indici (i,j) nella posizione i⋅C+j:
int *m = (int *)malloc((size_t)R * C * sizeof(int));/* Accesso all'elemento di riga i e colonna j: */m[i * C + j] = 42;/* Deallocazione in un solo colpo: */free(m);
Vantaggi: Una sola malloc e una sola free, zero rischio di frammentazione, massima efficienza della cache CPU perché tutti gli elementi sono adiacenti in RAM.
Patologie della memoria dinamica e diagnosi con valgrind
Poiché il linguaggio C non possiede un Garbage Collector automatico, errori nella gestione manuale dello Heap portano a bug critici di affidabilità e sicurezza:
Memory Leak (Perdita di memoria):
Si verifica quando si perde ogni riferimento (puntatore) a un blocco allocato nello Heap senza aver chiamato free. Quel blocco resta “occupato” fino alla fine del processo. In programmi a lunga esecuzione (server, demoni, sistemi embedded), i memory leak esauriscono progressivamente la RAM fino al crash del sistema.
void funzione_con_leak(void) { int *p = (int *)malloc(1000 * sizeof(int)); p[0] = 10; /* La funzione termina: p sparisce dallo Stack, ma i 4000 byte nello Heap non sono stati liberati con free(p)! */}
Dangling Pointer e Use-After-Free:
Un puntatore diventa dangling (“penzolante”) quando continua a puntare a un’area di memoria che è già stata deallocata (tramite free o perché apparteneva a un record di attivazione dello Stack ormai distrutto). Leggere o scrivere attraverso un dangling pointer (use-after-free) causa Undefined Behavior: può leggere dati corrotti, sovrascrivere strutture interne dell’allocatore o provocare un Segmentation fault.
int *p = (int *)malloc(sizeof(int));*p = 25;free(p);*p = 99; /* ERRORE GRAVE (Use-After-Free): p punta a memoria già liberata! */
Double Free (Doppia deallocazione):
Chiamare free(p) due volte sullo stesso indirizzo senza che sia stato riassegnato corrompe le liste dei blocchi liberi dell’allocatore dello Heap, portando quasi sempre all’aborto immediato del programma (free(): double free detected) o a vulnerabilità di sicurezza sfruttabili.
Prevenzione: Impostare sempre p = NULL; subito dopo free(p); (poiché free(NULL) è innocuo).
Buffer Heap Overflow:
Scrivere oltre i limiti del blocco allocato (es. allocare N interi e scrivere in p[N], ricordando che gli indici validi vanno da 0 a N - 1). Spesso sovrascrive i metadati nascosti che malloc memorizza subito prima o dopo il blocco nello Heap, facendo fallire una successiva free() o malloc() lontano dal punto del vero errore!
Individuare gli errori con valgrind
Valgrind con Memcheck può individuare accessi non validi, uso di valori non inizializzati e allocazioni perdute. Compiliamo con -g per associare il report alle righe del sorgente. --track-origins=yes aiuta a risalire all’origine dei valori non inizializzati. --leak-check=full --show-leak-kinds=all dettaglia i blocchi rimasti a fine esecuzione.
Partiamo dal tipo di errore e dalla prima riga del nostro codice indicata nella traccia. Invalid read e Invalid write segnalano accessi non validi. Conditional jump or move depends on uninitialised value(s) segnala l’uso di un valore non inizializzato in una decisione. definitely lost indica blocchi allocati che il programma non può più raggiungere. Il report riguarda l’esecuzione con gli ingressi provati. Per un controllo complementare possiamo compilare e collegare con -fsanitize=address -g e provare quel binario in una sessione separata.
Esempio intenzionalmente errato. Una scrittura attraverso un puntatore nullo ha comportamento indefinito. Salvando il seguente programma come programma.c, Memcheck può mostrare una traccia come quella sotto. Il numero di riga, gli indirizzi e la dimensione riportata dipendono dalla compilazione e dalla piattaforma.
#include <stddef.h>int main(void) { int *p = NULL; *p = 42; /* Accesso intenzionalmente non valido. */ return 0;}
Report illustrativo su un sistema con sizeof(int) == 4
Invalid write of size 4 at ...: main (programma.c:5) Address 0x0 is not stack'd, malloc'd or (recently) free'd
Per scrivere un valore serve un indirizzo valido, per esempio quello di un oggetto int x inizializzato nella stessa funzione. Se il puntatore proviene da un’allocazione, controlliamo prima che l’allocazione sia riuscita.
Dimensioni, errori di allocazione e proprietà del blocco
Per allocare n oggetti del tipo puntato da p controlliamo prima n <= SIZE_MAX / sizeof *p, con SIZE_MAX da <stdint.h>. Per n == 0 decidiamo esplicitamente se liberare il blocco e impostare p = NULL. Per una dimensione positiva, salviamo il risultato di realloc in un temporaneo. Se fallisce, p e la vecchia capacità restano validi. In caso di successo aggiorniamo entrambi e ricaviamo di nuovo i puntatori agli elementi. Il vecchio oggetto è terminato anche se l’indirizzo restituito ha lo stesso valore numerico.
Per una matrice allocata riga per riga, teniamo il numero di righe completate. Se fallisce l’allocazione della riga k, liberiamo le righe con indici da 0 a k-1 e poi il vettore dei puntatori. Liberare soltanto il vettore non libera le righe. Una funzione che restituisce un vettore allocato documenta la dimensione, come segnala un fallimento e che il chiamante è responsabile di free. Se restituisce un indirizzo preso in prestito, deve documentare invece la durata dell’oggetto proprietario.
Esempi guidati
Esempio 1: Vettore dinamico ad espansione geometrica (raddoppio della capacità)
Problema: Leggere da tastiera una sequenza di numeri interi di lunghezza ignota a priori (terminata da 0), memorizzandoli in un array dinamico che parte da capacità iniziale 2 e raddoppia la propria dimensione con realloc ogni volta che si riempie.
#include <stdio.h>#include <stdlib.h>int main(void) { size_t capacita = 2; /* Capacità iniziale dello Heap */ size_t n = 0; /* Numero di elementi effettivamente inseriti */ int *v = (int *)malloc(capacita * sizeof(int)); if (v == NULL) { fprintf(stderr, "Errore di allocazione iniziale\n"); return EXIT_FAILURE; } int valore; printf("Inserisci interi (0 per terminare):\n"); while (scanf("%d", &valore) == 1 && valore != 0) { /* Se l'array è pieno, raddoppiamo la capacità con realloc */ if (n == capacita) { size_t nuova_cap = capacita * 2; int *tmp = (int *)realloc(v, nuova_cap * sizeof(int)); if (tmp == NULL) { fprintf(stderr, "Errore: realloc fallita a capacita %zu\n", nuova_cap); free(v); /* Liberiamo il blocco originale ancora valido! */ return EXIT_FAILURE; } v = tmp; capacita = nuova_cap; printf(" [Debug] Capacita raddoppiata a %zu elementi\n", capacita); } v[n] = valore; n++; } printf("Hai inserito %zu elementi: ", n); for (size_t i = 0; i < n; i++) { printf("%d ", v[i]); } printf("\n"); free(v); v = NULL; return EXIT_SUCCESS;}
Traccia di esecuzione per l’input 10 20 30 40 50 0:
All’inizio capacita = 2, n = 0.
Legge 10→v[0] = 10, n = 1.
Legge 20→v[1] = 20, n = 2.
Legge 30→n == capacita (2==2): realloc porta capacita a 4, poi v[2] = 30, n = 3.
Legge 40→v[3] = 40, n = 4.
Legge 50→n == capacita (4==4): realloc porta capacita a 8, poi v[4] = 50, n = 5.
Legge 0→ esce dal ciclo, stampa 10 20 30 40 50 e libera v.
Esempio 2: Duplicazione dinamica di una stringa (mia_strdup)
Problema: Scrivere una funzione che riceve una stringa C (const char *s) e ne restituisce una copia indipendente allocata dinamicamente nello Heap.
#include <stdio.h>#include <stdlib.h>#include <string.h>char *mia_strdup(const char *s) { if (s == NULL) { return NULL; } /* ATTENZIONE: strlen(s) non conta il terminatore '\0'! Servono strlen(s) + 1 byte. */ size_t len = strlen(s); char *copia = (char *)malloc((len + 1) * sizeof(char)); if (copia == NULL) { return NULL; } /* Copiamo tutti i caratteri incluso il '\0' finale */ memcpy(copia, s, len + 1); return copia;}int main(void) { char *testo = mia_strdup("Programmazione in C"); if (testo != NULL) { printf("Copia nello Heap: %s\n", testo); free(testo); testo = NULL; } return 0;}
Esempio 3: Costruzione e trasposizione di una matrice dinamica R×C
Problema: Allocare dinamicamente una matrice R×C, calcolarne la trasposta C×R in una nuova matrice dinamica e liberare entrambe correttamente.
#include <stdio.h>#include <stdlib.h>int **crea_matrice(int r, int c) { int **m = (int **)malloc(r * sizeof(int *)); if (!m) return NULL; for (int i = 0; i < r; i++) { m[i] = (int *)calloc(c, sizeof(int)); if (!m[i]) { for (int k = 0; k < i; k++) free(m[k]); free(m); return NULL; } } return m;}void distruggi_matrice(int **m, int r) { if (!m) return; for (int i = 0; i < r; i++) free(m[i]); free(m);}int main(void) { int R = 2, C = 3; int **A = crea_matrice(R, C); int **AT = crea_matrice(C, R); /* Dimensioni invertite C x R */ if (!A || !AT) { distruggi_matrice(A, R); distruggi_matrice(AT, C); return EXIT_FAILURE; } /* Riempiamo A e calcoliamo la trasposta AT[j][i] = A[i][j] */ int cont = 1; for (int i = 0; i < R; i++) { for (int j = 0; j < C; j++) { A[i][j] = cont++; AT[j][i] = A[i][j]; } } printf("Matrice trasposta (%d x %d):\n", C, R); for (int j = 0; j < C; j++) { for (int i = 0; i < R; i++) { printf("%3d ", AT[j][i]); } printf("\n"); } distruggi_matrice(A, R); distruggi_matrice(AT, C); return 0;}
Errori frequenti
Errori da evitare
Dimenticare il + 1 per il terminatore '\0' nelle stringhe dinamiche:
Scrivere malloc(strlen(s)) invece di malloc(strlen(s) + 1) provoca sistematicamente un Heap Buffer Overflow di 1 byte non appena strcpy scrive il carattere nulo finale.
Restituire l’indirizzo di una variabile locale sullo Stack invece di allocare sullo Heap:
int *crea_array_sbagliato(void) { int v[10]; /* Allocato sullo STACK! */ return v; /* ERRORE: v viene distrutto appena la funzione termina! */}
Per far sopravvivere un array oltre il ritorno della funzione che lo crea, deve essere allocato nello Heap con malloc/calloc.
Confondere sizeof(p) con la dimensione del blocco allocato:
Se int *p = malloc(100 * sizeof(int));, l’espressione sizeof(p) restituisce la dimensione della variabile puntatore (es. 8 byte su sistemi a 64 bit), non400! Il linguaggio C non fornisce alcun modo standard per chiedere a un puntatore quanti byte sono stati allocati con malloc: il programmatore deve conservare la dimensione N in una variabile separata.
Sbagliare il tipo dentro sizeof nell’allocazione di puntatori doppi:
Quando si alloca il vettore delle righe int **m, gli elementi di m sono puntatori int *, quindi ci vuole malloc(R * sizeof(int *)) (oppure malloc(R * sizeof(*m))), non sizeof(int) (che su macchine a 64 bit è 4 byte invece di 8 byte, dimezzando lo spazio necessario!).
Deallocare una matrice `int mfacendo solofree(m)**: Chiamare solo free(m)libera il vettore esterno dei puntatori alle righe, ma lascia tutte le $R$ righe orfane nello Heap (Memory Leak di $R$ blocchi). Se poi si tenta di farefree(m[i])*dopo*free(m)`, si commette un Use-After-Free.
Esercizi di prova
Esercizio 1. Media e filtraggio con calloc (Base)
Scrivi una funzione int *filtra_positivi(const int *v, int n, int *out_len) che, ricevuto un array v di n interi, conta quanti sono strettamente positivi (>0), alloca nello Heap un array della dimensione esatta necessaria, vi copia solo gli elementi positivi, scrive la nuova dimensione in *out_len e restituisce il puntatore al nuovo array (oppure NULL se non ci sono positivi o se malloc fallisce).
Soluzione
#include <stdio.h>#include <stdlib.h>int *filtra_positivi(const int *v, int n, int *out_len) { if (v == NULL || n <= 0 || out_len == NULL) { if (out_len) *out_len = 0; return NULL; } /* 1. Contiamo quanti elementi sono > 0 */ int conta = 0; for (int i = 0; i < n; i++) { if (v[i] > 0) { conta++; } } *out_len = conta; if (conta == 0) { return NULL; } /* 2. Allocazione esatta nello Heap */ int *ris = (int *)malloc(conta * sizeof(int)); if (ris == NULL) { *out_len = 0; return NULL; } /* 3. Copia dei soli valori positivi */ int j = 0; for (int i = 0; i < n; i++) { if (v[i] > 0) { ris[j++] = v[i]; } } return ris;}
Esercizio 2. Caccia al bug di memoria (Base)
Individua tutti gli errori di gestione della memoria nel seguente frammento e riscrivilo in modo corretto:
void elabora(int n) { int *a = malloc(n); for (int i = 0; i <= n; i++) { a[i] = i * 2; } free(a); printf("Ultimo elemento: %d\n", a[n - 1]); free(a);}
Soluzione
Il frammento contiene 5 gravi errori:
malloc(n) alloca solo nbyte anziché n * sizeof(int) byte.
Manca il controllo if (a == NULL) dopo malloc.
La condizione del ciclo i <= n scrive in a[n], causando un Heap Buffer Overflow (gli indici validi sono 0 .. n-1).
printf(..., a[n - 1]) viene eseguita dopofree(a): è un Use-After-Free (lettura tramite dangling pointer).
Viene chiamata free(a) una seconda volta alla fine: Double Free.
Versione corretta:
void elabora(int n) { if (n <= 0) return; int *a = (int *)malloc(n * sizeof(int)); if (a == NULL) return; for (int i = 0; i < n; i++) { a[i] = i * 2; } printf("Ultimo elemento: %d\n", a[n - 1]); free(a); a = NULL;}
Esercizio 3. Concatenazione dinamica di due stringhe (Intermedio)
Scrivi una funzione char *concatena(const char *s1, const char *s2) che restituisce una nuova stringa allocata dinamicamente contenente s1 seguita da s2, senza modificare le stringhe originali.
Soluzione
#include <stdlib.h>#include <string.h>char *concatena(const char *s1, const char *s2) { if (s1 == NULL || s2 == NULL) return NULL; size_t len1 = strlen(s1); size_t len2 = strlen(s2); /* +1 per il terminatore '\0' finale */ char *ris = (char *)malloc((len1 + len2 + 1) * sizeof(char)); if (ris == NULL) return NULL; memcpy(ris, s1, len1); memcpy(ris + len1, s2, len2 + 1); /* Copia anche il '\0' di s2 */ return ris;}
Esercizio 4. Ridimensionamento su misura con realloc (Intermedio)
Scrivi una funzione int *leggi_e_compatta(size_t *dim_finale) che alloca inizialmente un blocco per 100 interi, legge interi da stdin finché non incontra un numero negativo (o massimo 100 numeri), e prima di restituire l’array usa realloc per ridurre il blocco nello Heap all’esatto numero di elementi effettivamente letti.
Soluzione
#include <stdio.h>#include <stdlib.h>int *leggi_e_compatta(size_t *dim_finale) { size_t cap = 100; size_t n = 0; int *v = (int *)malloc(cap * sizeof(int)); if (v == NULL) { *dim_finale = 0; return NULL; } int x; while (n < cap && scanf("%d", &x) == 1 && x >= 0) { v[n++] = x; } *dim_finale = n; if (n == 0) { free(v); return NULL; } /* Compattiamo il blocco esattamente a n elementi */ int *ridotto = (int *)realloc(v, n * sizeof(int)); if (ridotto != NULL) { v = ridotto; } return v;}
Scrivi una funzione int **crea_triangolare(int n) che alloca nello Heap una matrice “a scalini” di n righe, dove la riga i (con 0≤i<n) ha esattamente i + 1 colonne (evitando di sprecare memoria per gli elementi sopra la diagonale), e riempie ogni cella (i, j) con il coefficiente binomiale del Triangolo di Tartaglia (ji). Scrivi anche la corrispondente funzione di deallocazione.
Soluzione
#include <stdio.h>#include <stdlib.h>int **crea_triangolare(int n) { if (n <= 0) return NULL; int **t = (int **)malloc(n * sizeof(int *)); if (t == NULL) return NULL; for (int i = 0; i < n; i++) { /* La riga i ha solo (i + 1) colonne! */ t[i] = (int *)malloc((i + 1) * sizeof(int)); if (t[i] == NULL) { for (int k = 0; k < i; k++) free(t[k]); free(t); return NULL; } /* Primo e ultimo elemento della riga valgono 1 */ t[i][0] = 1; t[i][i] = 1; /* Elementi interni: somma dei due sopra nella riga precedente */ for (int j = 1; j < i; j++) { t[i][j] = t[i - 1][j - 1] + t[i - 1][j]; } } return t;}void libera_triangolare(int **t, int n) { if (t == NULL) return; for (int i = 0; i < n; i++) { free(t[i]); } free(t);}
Esercizio 6. Eliminazione di una riga da una matrice dinamica in O(1) (Avanzato)
Data una matrice dinamica allocata come int **m di R righe e C colonne, scrivi una funzione int elimina_riga(int ***m_ptr, int *R_ptr, int idx) che elimina la riga di indice idx (0≤idx<R) liberandone la memoria, fa scorrere i puntatori delle righe successive e riduce il vettore esterno dei puntatori con realloc, aggiornando *R_ptr.
Soluzione
Poiché ogni riga è un blocco indipendente nello Heap, non serve copiare i C elementi delle righe successive: basta liberare m[idx] e far scorrere i puntatorim[i] = m[i + 1]!
#include <stdlib.h>int elimina_riga(int ***m_ptr, int *R_ptr, int idx) { if (m_ptr == NULL || *m_ptr == NULL || R_ptr == NULL) return -1; int R = *R_ptr; if (idx < 0 || idx >= R) return -1; int **m = *m_ptr; /* 1. Liberiamo la memoria della riga da eliminare */ free(m[idx]); /* 2. Facciamo scorrere a sinistra i puntatori alle righe successive */ for (int i = idx; i < R - 1; i++) { m[i] = m[i + 1]; } *R_ptr = R - 1; if (*R_ptr == 0) { free(m); *m_ptr = NULL; return 0; } /* 3. Riduciamo il vettore dei puntatori alle righe */ int **tmp = (int **)realloc(m, (*R_ptr) * sizeof(int *)); if (tmp != NULL) { *m_ptr = tmp; } return 0;}
Provenienza del materiale
Dispensa ufficiale del corso: C1PROG1U4L1_Memoria_dinamica tag accessibilità.pdf (Unità 4, Lezione 1 — Allocazione dinamica della memoria).
Marco Anisetti, Memoria, Appunti_di_Fine_Unità_4.pdf, cap. 1.