Le funzioni in C

Come scomporre un programma con le funzioni

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 main non 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 nome_funzione(Tipo1 param1, Tipo2 param2)
  • 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):

  1. 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à).
  2. 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:

  1. Nella firma di una funzione, scrivere void elabora(int v[], int n) è al 100% identico a scrivere void elabora(int *v, int n).
  2. 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[]).
  3. 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.

gcc -std=c11 -Wall -Wextra -Werror -g -O0 scambio.c -o scambio
gdb ./scambio

Al prompt di GDB:

break swap
run
print *a
print *b
backtrace
next
finish
print x
print y
quit

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

  1. 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!
  2. 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! */
    }
  3. 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;
}

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.

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.

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.

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.

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 colonne.


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.
  • WG14, bozza C11 N1570, §§ 6.5.2.2 e 6.7.6.3.
  • Dispensa del corso, C1PROG1_Guida_Installazione_VM-rev1.pdf (Ambiente Linux, macchina virtuale e toolchain C).
  • Dispensa del corso, C1PROG1B3L4_Puntatori_e_Vettori.pdf (Memoria, puntatori e vettori).