Parametri e macro del preprocessore

Che cosa succede prima che il C venga compilato

Nella Lezione 2.1.1 abbiamo scoperto che il primo strumento della catena di compilazione è il Preprocessore (cpp), che trasforma il testo del codice sorgente eseguendo le direttive che iniziano con # prima ancora che il compilatore C entri in azione.

Finora abbiamo usato #define solo per dare un nome a semplici costanti numeriche (#define N 100). Ma il preprocessore può fare molto di più: permette di definire macro parametriche che assomigliano in tutto e per tutto a delle funzioni (come #define MAX(a, b) ... o #define SQR(x) ...), e permette di compilare o escludere intere porzioni di codice tramite la compilazione condizionale (#ifdef, #ifndef, #endif).

Tuttavia, poiché il preprocessore non conosce la grammatica del C ma esegue una pura sostituzione testuale (“copia e incolla”), le macro parametriche nascondono due trappole famosissime — la mancanza di parentesi e gli effetti collaterali (side effects) — che sono tra i quesiti preferiti di ogni esame di Programmazione C!


Direttive del Preprocessore e Compilazione Condizionale

1. #include <file.h> vs #include "file.h"

Qual è la differenza tra usare le parentesi angolari <...> e i doppi apici "..."?

  • #include <stdio.h>: cerca il file header esclusivamente nelle cartelle standard di sistema (es. /usr/include). Si usa per le librerie del linguaggio.
  • #include "mio_modulo.h": cerca il file header prima nella cartella corrente del nostro progetto, e solo se non lo trova lì passa alle cartelle di sistema. Si usa per i file .h scritti da noi!

2. #define e #undef

  • #define NOME testo_sostitutivo: definisce un simbolo o una macro a partire da quella riga fino alla fine del file.
  • #undef NOME: cancella la definizione precedente di NOME.

3. Compilazione Condizionale (#ifdef, #ifndef, #if, #else, #endif)

Permette di decidere quali righe di codice consegnare al compilatore in base al fatto che una macro sia stata definita o meno:

#define MODALITA_DEBUG
 
int main(void) {
    int x = 42;
#ifdef MODALITA_DEBUG
    /* Questa riga esiste per il compilatore SOLO SE MODALITA_DEBUG è definita! */
    printf("[DEBUG] Valore di x = %d\n", x);
#endif
    return 0;
}

(Nota: una macro può essere definita anche direttamente da riga di comando durante la compilazione usando il flag -D di gcc, ad esempio: gcc -DMODALITA_DEBUG main.c).

4. Le Include Guards (Guardie di inclusione) nei file Header .h

Nei progetti divisi in più file, capita spesso che main.c includa sia "geometria.h" sia "disegno.h", e che a sua volta "disegno.h" includa "geometria.h". Senza una protezione, il contenuto di "geometria.h" verrebbe incollato due volte dentro main.c, causando errori di ridefinizione di tipi e strutture!

Per impedire l’inclusione multipla, ogni file .h deve sempre essere racchiuso in una Include Guard:

/* File: geometria.h */
#ifndef GEOMETRIA_H   /* 1. Se il simbolo GEOMETRIA_H NON è ancora stato definito... */
#define GEOMETRIA_H   /* 2. ...definiscilo subito adesso... */
 
/* ...e includi il contenuto del file header: */
typedef struct {
    double x, y;
} Punto;
 
double distanza(Punto a, Punto b);
 
#endif /* GEOMETRIA_H — 3. Se venisse incluso una seconda volta, #ifndef sarebbe Falso e salterebbe tutto! */
flowchart TD
    INC["Il preprocessore incontra\n#include \"geometria.h\""] --> GUARD{"GEOMETRIA_H è\ngià definito?"}
    GUARD -->|"No (1ª volta)"| DEF["Definisce GEOMETRIA_H\ne copia il codice dell'header"]
    GUARD -->|"Sì (2ª volta)"| SKIP["Salta tutto fino a #endif\n(Evita errori di ridefinizione!)"]

Le Macro Parametriche e le loro 2 Grandi Trappole

Una macro parametrica ha la forma:

#define NOME_MACRO(param1, param2) testo_di_espansione

Attenzione sintattica: NON ci deve essere nessuno spazio tra il nome della macro e la parentesi tonda aperta (! Se scrivete #define SQR (x) ((x)*(x)) con uno spazio prima di (x), il preprocessore pensa che SQR sia una macro senza parametri il cui testo inizia con (x)!

Trappola 1: Perché servono TUTTE le parentesi attorno ai parametri e all’intera macro!

Supponiamo di voler creare una macro che calcola il quadrato di un numero e di scriverla ingenuamente senza parentesi:

#define SQR_ERRATO(x) x * x

Cosa succede se nel main chiamiamo SQR_ERRATO(3 + 2) sperando di calcolare ?
Il preprocessore non calcola 3 + 2 prima di passarlo, ma sostituisce letteralmente il testo 3 + 2 al posto di ogni x:

Poiché in C la moltiplicazione * ha precedenza sull’addizione +, il compilatore calcola:

E se mettiamo le parentesi solo attorno ai parametri: #define SQR_QUASI(x) (x) * (x)?
Se poi scriviamo 100 / SQR_QUASI(5) sperando di calcolare , il preprocessore espande in:

Regola d’oro delle Macro Parametriche:

  1. Metti sempre le parentesi tonde attorno a ogni singola occorrenza di ciascun parametro: (x).
  2. Metti sempre una coppia di parentesi tonde esterna attorno all’intera espressione della macro:
#define SQR(x)    ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(x)    ((x) >= 0 ? (x) : -(x))

Trappola 2: Gli Effetti Collaterali (Side Effects) nella doppia valutazione!

Anche se abbiamo messo tutte le parentesi con #define SQR(x) ((x) * (x)) oppure #define MAX(a, b) ((a) > (b) ? (a) : (b)), c’è un pericolo che nessuna parentesi può risolvere: il parametro x (o a/b) compare due volte nel testo espanso!

Cosa succede se passiamo alla macro un’espressione con effetto collaterale come un incremento i++ o una chiamata a funzione leggi_input()?
Vediamo cosa succede con:

int i = 4;
int ris = MAX(i++, 3);

Espandiamo testualmente la macro MAX:

  1. Prima viene valutata la condizione (i++) > (3): poiché 4 > 3 è Vero, i viene incrementato una prima volta diventando 5.
  2. Poi viene valutato il ramo vero (i++): restituisce 5, e i viene incrementato una seconda volta diventando 6!
    Quindi i è stato incrementato due volte invece di una sola! (E nel caso di SQR(i++), che si espande in ((i++) * (i++)), modificare due volte la stessa variabile nella stessa espressione senza punto di sequenza è addirittura Undefined Behavior!).

Confronto tra Macro (#define) e Funzioni C (anche static inline)

CaratteristicaMacro Parametrica (#define)Funzione C (int f(int x))
Chi la elaboraPreprocessore (sostituzione testuale)Compilatore (analisi sintattica e dei tipi)
Controllo dei tipi (Type Safety)Nessuno (funziona con int, double, ecc., ma accetta anche tipi insensati)Rigoroso (controlla i tipi dei parametri a compilazione)
Valutazione degli argomentiValutati ogni volta che compaiono nel corpo (pericolo side effects con i++!)Valutati una sola volta prima di entrare nella funzione (sicura con i++)
Velocità / OverheadNessun salto di chiamata (il codice è espanso in loco, ma ingrandisce il binario)Piccolo overhead per creare lo Stack Frame (eliminabile in C99/C11 con static inline)
Debugging in gdbDifficile (non si può mettere un breakpoint dentro una macro)Facile (ispezionabile passo-passo con step in gdb)

Tre domande per leggere una macro

  1. Espansione. Quali token sostituisce il preprocessore? Con #define QUADRATO(x) ((x) * (x)), la chiamata testuale QUADRATO(a + b) diventa ((a + b) * (a + b)).
  2. Precedenza. Come interpreta l’espressione il compilatore dopo l’espansione? Le parentesi mantengono insieme gli operandi e il risultato quando compare, per esempio, in 2 / QUADRATO(a + b).
  3. Valutazione. Quante volte compare l’argomento? QUADRATO(i++) produce due modifiche non sequenziate di i. Per interi in un intervallo in cui il prodotto è rappresentabile, static inline int quadrato(int x) { return x * x; } valuta l’argomento una volta.

Una macro resta definita fino a #undef o alla fine dell’unità di preprocessing. Una funzione static inline definita in un header ha invece linkage interno in ogni unità di traduzione che la include. Vedi scope e linkage.


Esempi guidati

Esempio 1: Analisi passo-passo di espansione di macro con e senza parentesi

#include <stdio.h>
 
#define DOPPIO_BAD(x) 2 * x
#define DOPPIO_OK(x)  (2 * (x))
 
int main(void) {
    /* 1. Espansione di DOPPIO_BAD(10 + 5):
          diventa 2 * 10 + 5 = 20 + 5 = 25! */
    int a = DOPPIO_BAD(10 + 5);
 
    /* 2. Espansione di DOPPIO_OK(10 + 5):
          diventa (2 * (10 + 5)) = 2 * 15 = 30! */
    int b = DOPPIO_OK(10 + 5);
 
    printf("DOPPIO_BAD(10 + 5) = %d\n", a); /* Stampa 25 */
    printf("DOPPIO_OK(10 + 5)  = %d\n", b); /* Stampa 30 */
    return 0;
}

Esempio 2: Macro multi-istruzione (Scambio di due variabili generiche)

È possibile scrivere una macro SWAP(Tipo, a, b) che scambi due variabili di qualunque tipo Tipo usando un blocco locale { ... }:

#include <stdio.h>
 
#define SWAP(Tipo, a, b) do { \
    Tipo temp_swap = (a);     \
    (a) = (b);                \
    (b) = temp_swap;          \
} while (0)
 
int main(void) {
    int x = 10, y = 20;
    SWAP(int, x, y);
    printf("Interi scambiati: %d, %d\n", x, y);
 
    double d1 = 1.5, d2 = 9.9;
    SWAP(double, d1, d2);
    printf("Double scambiati: %.1f, %.1f\n", d1, d2);
    return 0;
}

Nota tecnica avanzata: Il carattere \ in fondo alla riga permette di continuare una #define sulla riga successiva, e l’idioma do { ... } while (0) permette di usare SWAP(int, x, y); con il punto e virgola finale dentro un if (...) SWAP(...); else ... senza creare errori di sintassi!


Errori frequenti

Errori da evitare

  1. Valutare mentalmente gli argomenti di una macro come se fosse una funzione
    Quando risolvi un esercizio d’esame con una #define, non fare mai il calcolo a mente prima di sostituire: scrivi prima su carta il testo letterale espanso dal preprocessore, e solo dopo applica le precedenze degli operatori C!
  2. Mettere uno spazio tra il nome della macro e la parentesi aperta (
    #define CUBO (x) ((x)*(x)*(x)) è sbagliato perché quello spazio dopo CUBO trasforma (x) in parte del testo sostituito! Deve essere #define CUBO(x) ....
  3. Passare argomenti con ++ o -- a una macro parametrica
    Mai scrivere MAX(a++, b) o ABS(--x). Incrementa sempre la variabile su una riga separata prima di invocare la macro.

Esercizi di prova

Esercizio 1. Espansione testuale e precedenze degli operatori (Base)

Data la seguente macro scritta senza parentesi:

#defineDIFF(a, b) a - b
#define PROD(a, b) a * b

Calcola il valore intero esatto delle seguenti due espressioni dopo l’espansione del preprocessore:
a) int x = 20 - DIFF(10, 3);
b) int y = PROD(2 + 3, 4 + 1);
Riscrivi poi entrambe le macro in modo completamente corretto.

Esercizio 2. Scrittura di macro sicure (Base)

Scrivi le direttive #define completamente parentesizzate per:
a) PARI(n): vale 1 se l’intero n è pari, 0 altrimenti.
b) TRA(x, min, max): vale 1 se x è compreso nell’intervallo chiuso , 0 altrimenti.

Esercizio 3. Trappola degli effetti collaterali (Side Effects (Intermedio)

Considera il seguente programma:

#include <stdio.h>
#define MAGGIORE(a, b) ((a) > (b) ? (a) : (b))
 
int main(void) {
    int x = 10, y = 5;
    int m = MAGGIORE(++x, y);
    printf("x = %d, y = %d, m = %d\n", x, y, m);
    return 0;
}

Espandi la macro e determina i valori stampati di x, y e m. Cosa sarebbe stato stampato se MAGGIORE fosse stata una vera funzione C int maggiore(int a, int b)?

Esercizio 4. Compilazione condizionale con #if / #ifdef (Intermedio)

Determina cosa stampa il seguente programma:

#include <stdio.h>
#define VERSIONE 2
#define ATTIVA_EXTRA
#undef ATTIVA_EXTRA
 
int main(void) {
    int ris = 10;
#ifdef ATTIVA_EXTRA
    ris = ris + 100;
#endif
#if VERSIONE >= 2
    ris = ris * 2;
#else
    ris = ris + 1;
#endif
    printf("ris = %d\n", ris);
    return 0;
}

Esercizio 5. Costruzione di un file Header .h completo con Include Guard (Avanzato)

Scrivi il contenuto completo di un file header chiamato vettori_util.h dotato di Include Guard standard, che definisca una macro costante CAPACITA_MAX pari a 256 e dichiari i prototipi di due funzioni: void stampa_vettore(const int v[], int n) e int cerca_elemento(const int v[], int n, int target).


Provenienza del materiale

  • Slide e dispensa ufficiale del corso: C1PROG1U3L2_Parametri_e_Macro tag.pdf (Unità 3, Lezione 2 — Direttive del preprocessore, macro parametriche e compilazione condizionale).
  • Marco Anisetti, Funzioni, Appunti_di_Fine_Unità_3.pdf, cap. 2.
  • Marco Anisetti, Memoria, Appunti_di_Fine_Unità_4.pdf, cap. 3.
  • WG14, bozza C11 N1570, §§ 6.2.1–6.2.2 e 6.10.3.