Finora abbiamo scritto tutto il nostro codice dentro un’unica funzione: main. Ma cosa succede quando un programma cresce fino a 10.000 o 100.000 righe? Scrivere tutto dentro un unico blocco gigante renderebbe il codice illeggibile, pieno di ripetizioni e impossibile da testare.
Il principio ingegneristico fondamentale per dominare la complessità è il Divide et Impera (Decomposizione Modulare): scomporre un problema grande in sottoproblemi più piccoli, autonomi e riutilizzabili, ciascuno affidato a una funzione (o sottoprogramma).
Ma per padroneggiare davvero le funzioni in C bisogna capire cosa succede nella memoria RAM (nello Stack delle chiamate) quando una funzione viene invocata: perché se modifichiamo una variabile normale dentro una funzione la variabile del mainnon cambia (passaggio per valore), e come possiamo invece usare i puntatori per permettere a una funzione di modificare le variabili del chiamante?
Anatomia di una Funzione: Prototipo, Definizione e Chiamata
1. Firma, Parametri Formali e Argomenti Attuali
Una funzione è caratterizzata dalla sua firma (o intestazione):
TipoRitorno: il tipo del risultato restituito tramite l’istruzione return espressione;. Se la funzione compie solo un’azione (es. stampa a video o modifica tramite puntatori) senza restituire alcun valore, il tipo di ritorno è void.
Parametri Formali (param1, param2): sono le variabili locali dichiarate tra le parentesi tonde nella definizione della funzione, che ricevono i dati in ingresso. (Se una funzione non accetta alcun parametro, in C si scrive (void) tra le parentesi).
Argomenti Attuali (o Effettivi): sono i valori o le espressioni concrete passate tra parentesi al momento della chiamata della funzione (es. ris = somma(a + 1, 10);).
2. Dichiarazione (Prototipo) vs Definizione
Il compilatore C legge il file sorgente rigorosamente dall’alto verso il basso in una sola passata. Se dentro main chiamiamo una funzione calcola(5) che è definita più in basso nel file, il compilatore non la conosce ancora e segnala un errore!
Per risolvere questo problema, si separa:
La Dichiarazione (o Prototipo): messa in cima al file (o in un file header .h), presenta al compilatore solo la firma della funzione chiusa da un punto e virgola ;, senza il corpo:
int quadrato(int x); /* Prototipo: dice al compilatore che la funzione esiste */
La Definizione: contiene l’implementazione effettiva (il blocco { ... } del corpo) e può trovarsi sotto il main o in un altro file .c:
int quadrato(int x) { return x * x;}
Lo Stack delle Chiamate e i Record di Attivazione (Stack Frame)
Cosa accade fisicamente nella memoria RAM quando main chiama una funzione f(), e f() a sua volta chiama g()?
Il sistema utilizza una regione della memoria RAM organizzata a Pila (LIFO: Last-In, First-Out) chiamata Call Stack (Pila delle chiamate):
Alla chiamata della funzione (Push): viene creato in cima allo Stack un blocco di memoria dedicato a quella specifica invocazione, chiamato Record di Attivazione (o Stack Frame), che contiene:
Le copie dei parametri formali della funzione.
Tutte le variabili locali dichiarate dentro la funzione.
L’indirizzo di ritorno (il punto esatto della funzione chiamante a cui tornare quando la funzione terminerà).
Al return della funzione (Pop): l’intero Stack Frame della funzione terminata viene distrutto immediatamente, liberando lo spazio in memoria, e l’esecuzione riprende nella funzione chiamante!
flowchart TB
subgraph Stack["Memoria Call Stack durante l'esecuzione di main() -> incrementa(x)"]
direction TB
F_MAIN["Stack Frame di main()\n--------------------\nVariabile locale: x = 10\n(Indirizzo: 0x1000)"]
F_INC["Stack Frame di incrementa(int n)\n--------------------\nParametro formale: n = 10 (COPIA!)\n(Indirizzo: 0x0FE0 — Cella diversa!)\nIndirizzo di ritorno -> main"]
F_MAIN ==>|"Chiama incrementa(x)"| F_INC
end
Conseguenza fondamentale (Durata di vita delle variabili locali): Poiché lo Stack Frame di una funzione viene distrutto al return, è un errore gravissimo restituire l’indirizzo di una variabile locale (return &var_locale;)! Quel puntatore punterebbe a una zona dello Stack ormai distrutta (Dangling Pointer).
Passaggio per Valore vs Passaggio per Indirizzo (Puntatori)
Regola assoluta del linguaggio C: Tutto è passato PER VALORE!
In C, quando chiamiamo una funzione, il valore dell’argomento attuale viene copiato dentro la cella del parametro formale sullo Stack.
Guarda perché questo tentativo ingenuo di scambiare due variabili NON FUNZIONA:
/* VERSIONE SBAGLIATA: Passaggio per valore (scambia solo le copie locali!) */void swap_sbagliato(int a, int b) { int temp = a; a = b; b = temp;} /* Qui le copie 'a' e 'b' vengono distrutte! Le variabili del main sono intatte! */
Come modificare le variabili del chiamante: Passaggio per Indirizzo (Riferimento simulato coi Puntatori)
Se vogliamo che una funzione modifichi due variabili x e y che vivono nello Stack Frame del main, dobbiamo passare alla funzione i loro indirizzi di memoria (&x e &y) e ricevere quei due indirizzi in due parametri puntatori (int *a, int *b)!
Anche in questo caso il C passa per valore, ma il valore copiato è l’indirizzo della cella originale: dereferenziando il puntatore con *a e *b, la funzione accede direttamente alle celle x e y del main!
flowchart LR
subgraph MainFrame["Stack Frame di main()"]
X["int x = 5\n(Ind: 0x1000)"]
Y["int y = 9\n(Ind: 0x1004)"]
end
subgraph SwapFrame["Stack Frame di swap(int *a, int *b)"]
PA["int *a = 0x1000"]
PB["int *b = 0x1004"]
end
PA ==>|"*a accede e modifica x!"| X
PB ==>|"*b accede e modifica y!"| Y
/* VERSIONE CORRETTA: Passaggio per indirizzo tramite puntatori */void swap(int *a, int *b) { int temp = *a; /* Legge il valore nella cella puntata da a (cioè x) */ *a = *b; /* Scrive il valore di y direttamente nella cella di x */ *b = temp; /* Scrive il vecchio valore di x direttamente nella cella di y */}/* Nel main si chiama passando gli indirizzi: swap(&x, &y); */
Passaggio di Vettori (Array) alle Funzioni
Cosa succede quando passiamo un array int v[1000] a una funzione? Il C copia tutti i 1000 elementi sullo Stack? No! Copiare array grandi rallenterebbe enormemente il programma. Perciò in C vale la regola del decadimento a puntatore (Array-to-Pointer Decay):
Quando un vettore viene passato come argomento a una funzione, non viene copiato l’array, ma viene passato esclusivamente l’indirizzo del suo primo elemento (&v[0])!
Di conseguenza:
Nella firma di una funzione, scrivere void elabora(int v[], int n) è al 100% identico a scrivere void elabora(int *v, int n).
Qualsiasi modifica fatta a v[i] dentro la funzione modifica direttamente l’array originale del chiamante! (Se invece vogliamo garantire che la funzione legga soltanto il vettore senza poterlo modificare, lo dichiariamo const int v[]).
Poiché dentro la funzione v è solo un puntatore int * (8 byte), dentro la funzione sizeof(v) NON restituisce più la dimensione dell’array, ma sizeof(int *) (8 byte)! Perciò bisogna sempre passare esplicitamente anche la dimensione int n come secondo parametro (a meno che non sia una stringa terminata da '\0').
Dal prototipo alla chiamata
Per scomporre un problema fissiamo prima il contratto di ciascuna funzione: dati ricevuti, risultato, oggetti modificabili e condizioni di errore. Un prototipo come int cerca(const int v[], size_t n, int chiave); documenta che la funzione riceve un indirizzo, un numero di elementi e una chiave. Il compilatore usa il prototipo per convertire gli argomenti ai tipi dei parametri dichiarati. Con double media(double x, double y); e media(3, 4.5), x riceve 3.0. Nel C11 una lista vuota in int f(); non specifica i parametri. Usiamo int f(void); quando la funzione non ne accetta.
Il record di attivazione è un modello che spiega perché due invocazioni hanno parametri e variabili automatiche distinti. Lo standard C lascia al compilatore la disposizione concreta. In incrementa(&n), il parametro puntatore contiene una copia dell’indirizzo. Un’assegnazione a *p cambia n, mentre assegnare un altro indirizzo a p cambia soltanto il parametro locale. La ricorsione usa la stessa distinzione fra invocazioni.
Esempi guidati
Esempio 1: Funzione swap corretta e funzione con più risultati tramite puntatori
Una funzione C può restituire un solo valore col return. Come facciamo se una funzione dividi_con_resto deve calcolare e restituire due risultati (il quoziente e il resto)? Usiamo parametri puntatori di output!
#include <stdio.h>/* Prototipi delle funzioni */void swap(int *a, int *b);int dividi_con_resto(int dividendo, int divisore, int *quoziente, int *resto);int main(void) { int x = 10, y = 25; printf("Prima di swap: x = %d, y = %d\n", x, y); swap(&x, &y); /* Passiamo gli indirizzi con & */ printf("Dopo swap: x = %d, y = %d\n", x, y); int q, r; if (dividi_con_resto(17, 5, &q, &r) == 1) { printf("17 / 5 -> Quoziente = %d, Resto = %d\n", q, r); } return 0;}void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp;}/* Restituisce 1 se la divisione è valida, 0 se divisore == 0. Scrive i due risultati nelle celle puntate da 'quoziente' e 'resto'. */int dividi_con_resto(int dividendo, int divisore, int *quoziente, int *resto) { if (divisore == 0) { return 0; /* Errore: divisione per zero */ } *quoziente = dividendo / divisore; *resto = dividendo % divisore; return 1;}
Seguire swap con GDB
Salviamo il programma dell’esempio come scambio.c e compiliamo con le informazioni di debug. I valori di a e b sono copie degli indirizzi. Dentro swap, *a e *b accedono a x e y del chiamante.
break swap imposta un punto di arresto all’ingresso della funzione. Quando run lo raggiunge, print *a e print *b mostrano 10 e 25. backtrace mostra swap sopra main. next avanza nel corpo senza entrare in eventuali chiamate. Quando siamo invece fermi nel chiamante sulla riga di una chiamata, step permette di entrarci. finish prosegue fino al ritorno da swap. In main, x e y valgono ora 25 e 10.
Esempio 2: Funzioni che leggono (const) e modificano un vettore
#include <stdio.h>/* Legge soltanto l'array -> usiamo 'const int v[]' per proteggerlo */double calcola_media(const int v[], int n) { if (n <= 0) return 0.0; int somma = 0; for (int i = 0; i < n; i++) { somma += v[i]; } return (double)somma / n;}/* Modifica direttamente l'array originale del main raddoppiando ogni elemento */void raddoppia_elementi(int v[], int n) { for (int i = 0; i < n; i++) { v[i] = v[i] * 2; }}int main(void) { int dati[4] = {10, 20, 30, 40}; raddoppia_elementi(dati, 4); /* 'dati' diventa {20, 40, 60, 80} */ printf("Nuova media: %.2f\n", calcola_media(dati, 4)); /* Stampa 50.00 */ return 0;}
Errori frequenti
Errori da evitare
Usare sizeof(v) / sizeof(v[0]) dentro una funzione a cui è stato passato l’array v[]
Dentro void f(int v[]), v è decaduto a un semplice puntatore int *. Il compilatore gcc -Wall blocca questo errore con il messaggio: 'sizeof' on array function parameter 'v' will return size of 'int *'. Passa sempre int n come parametro!
Restituire l’indirizzo di una variabile locale o di un array locale (return &locale;)
int *crea_array_sbagliato(void) { int v[3] = {1, 2, 3}; return v; /* ERRORE CRITICO! 'v' vive sullo Stack e muore appena la funzione ritorna! */}
Confondere la chiamata swap(x, y) con swap(&x, &y)
Se la funzione accetta puntatori int *a, int *b, chiamarla bisogna passare gli indirizzi &x, &y.
Esercizi di prova
Esercizio 1. Traccia dello Stack: Passaggio per valore vs Passaggio per indirizzo (Base)
Determina cosa stampa il programma spiegando cosa accade nello stack. Come imposteresti in GDB un punto di arresto in mistero per seguire a e il valore puntato da b?
#include <stdio.h>void mistero(int a, int *b) { a = a + 10; *b = *b + a;}int main(void) { int x = 5, y = 20; mistero(x, &y); printf("x = %d, y = %d\n", x, y); return 0;}
Soluzione
x viene passato per valore al parametro a: dentro mistero, a parte da 5 e diventa 5 + 10 = 15, ma questa modifica avviene solo sulla copia locale a. La variabile x del mainrimane 5!
y viene passato per indirizzo (&y) al puntatore b: l’istruzione *b = *b + a modifica direttamente y sommandogli 15 (20 + 15 = 35).
Output stampato: x = 5, y = 35.
Per riprodurre la traccia, compiliamo mistero.c con -g -O0 e avviamo gdb ./mistero. Usiamo break mistero, run, print a e print *b. Dopo next, a vale 15 e *b vale ancora 20. Con finish torniamo nel chiamante e print y mostra 35.
Esercizio 2. Funzione di verifica di numero primo e uso nel main (Base)
Scrivi una funzione int e_primo(int n) che restituisca 1 se n è un numero primo e 0 altrimenti. Usala poi nel main per stampare tutti i numeri primi compresi tra 2 e 50.
Soluzione
#include <stdio.h>int e_primo(int n) { if (n < 2) { return 0; } for (int d = 2; d * d <= n; d++) { if (n % d == 0) { return 0; /* Trovato un divisore */ } } return 1;}int main(void) { printf("Numeri primi fino a 50: "); for (int k = 2; k <= 50; k++) { if (e_primo(k)) { printf("%d ", k); } } printf("\n"); return 0;}
Esercizio 3. Restituzione simultanea di Minimo e Massimo di un vettore (Intermedio)
Scrivi una funzione con firma: void trova_min_max(const int v[], int n, int *min, int *max);
che, dato un vettore v di n >= 1 interi, calcoli in una sola scansione sia il valore minimo sia il valore massimo del vettore e li scriva nelle variabili puntate da min e max.
Soluzione
#include <stdio.h>void trova_min_max(const int v[], int n, int *min, int *max) { *min = v[0]; *max = v[0]; for (int i = 1; i < n; i++) { if (v[i] < *min) { *min = v[i]; } if (v[i] > *max) { *max = v[i]; } }}int main(void) { int a[6] = {14, -5, 28, 3, 99, 0}; int minimo, massimo; trova_min_max(a, 6, &minimo, &massimo); printf("Minimo = %d, Massimo = %d\n", minimo, massimo); /* -5 e 99 */ return 0;}
Esercizio 4. Funzione su stringhe: conteggio occorrenze di un carattere (Intermedio)
Scrivi una funzione int conta_carattere(const char s[], char target) che restituisca quante volte il carattere target compare nella stringa s. Spiega perché per una stringa non è necessario passare la dimensione int n come parametro.
Soluzione
Non serve passare la dimensione n perché ogni stringa C valida contiene alla fine la sentinella '\0', che permette alla funzione di sapere autonomamente quando fermarsi:
int conta_carattere(const char s[], char target) { int cont = 0; for (int i = 0; s[i] != '\0'; i++) { if (s[i] == target) { cont++; } } return cont;}
Esercizio 5. Ordinamento di tre variabili tramite chiamate a swap (Avanzato)
Usando la funzione void swap(int *a, int *b), scrivi una funzione void ordina_tre(int *x, int *y, int *z) che riceva gli indirizzi di tre variabili intere e le riordini in modo tale che al termine valga *x <= *y <= *z.
Soluzione
Bastano 3 confronti con scambio (come una piccola rete di ordinamento a 3 fili):
void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp;}void ordina_tre(int *x, int *y, int *z) { if (*x > *y) swap(x, y); /* Ora *x <= *y */ if (*y > *z) swap(y, z); /* Ora *z è sicuramente il massimo dei tre! */ if (*x > *y) swap(x, y); /* Riordina i primi due se il vecchio *z era il più piccolo */}
Esercizio 6. Passaggio di Matrici 2D a una funzione (Avanzato)
Quando si passa una matrice bidimensionale int m[R][C] a una funzione in C, il numero di righe R può essere lasciato vuoto o passato a parte, ma il numero di colonne C deve essere specificato tra le parentesi quadre nella firma della funzione (es. int somma_matrice(int m[][C], int righe)).
a) Spiega usando la formula di indirizzamento Row-Major perché il compilatore ha assolutamente bisogno di conoscere il numero di colonne C per calcolare m[r][c].
b) Scrivi la funzione int somma_matrice(const int m[][4], int righe) che restituisce la somma di tutti gli elementi di una matrice di righe×4 colonne.
Soluzione
a) Motivo teorico: In memoria Row-Major, l’indirizzo di m[r][c] è Base(m)+(r⋅C+c)×sizeof(int). Per sapere di quanti elementi saltare in avanti quando si passa dalla riga 0 alla riga r, il compilatore deve moltiplicare r per la larghezza della riga C! Il numero totale di righe R invece non compare nella formula di indirizzamento.
b) Implementazione:
int somma_matrice(const int m[][4], int righe) { int totale = 0; for (int r = 0; r < righe; r++) { for (int c = 0; c < 4; c++) { totale += m[r][c]; } } return totale;}
Provenienza del materiale
Slide e dispensa ufficiale del corso: C1PROG1U3L1_Funzioni.pdf (Unità 3, Lezione 1 — Le funzioni in C, record di attivazione, passaggio per valore e per indirizzo).
Marco Anisetti, Funzioni, Appunti_di_Fine_Unità_3.pdf, capp. 1–3.