Guida C interattiva: Puntatori a funzione

Q: Come si dichiara un puntatore a funzione in C?

Scrivi la firma della funzione con (nome) al posto del nome della funzione: int (op)(int, int); dichiara op come puntatore a una funzione che prende due int e restituisce un int. Le parentesi attorno a *op sono obbligatorie: senza di esse dichiari una funzione che restituisce un puntatore.

Q: Come si chiama una funzione tramite un puntatore?

Con op(3, 4) oppure con (*op)(3, 4): sono entrambe valide e fanno la stessa cosa, perché il nome di una funzione si converte automaticamente in un puntatore. Il codice C moderno usa la forma semplice op(3, 4).

Il codice compilato vive in memoria proprio come i dati, quindi una funzione ha un indirizzo. Un puntatore a funzione è una variabile che ne memorizza uno, e una volta che puoi memorizzare una funzione puoi passarla come argomento, tenerne una tabella o scegliere tra più funzioni a runtime.

È la capacità che sta dietro all'ordinamento con un criterio personalizzato, ai gestori di eventi, alle interfacce per i plugin e alle macchine a stati. È anche il pezzo di sintassi C che più facilmente costringe chi legge a fermarsi e strizzare gli occhi, quindi partiamo da lì.

La sintassi della dichiarazione

Prendi una funzione qualsiasi:

int add(int a, int b);

Per dichiarare un puntatore che possa contenerne l'indirizzo, sostituisci il nome con (*name):

int (*op)(int, int);

Leggila dall'interno: op è un puntatore, a una funzione, che prende (int, int), e restituisce int.

Le parentesi non sono decorative. Senza di esse, * si lega al tipo di ritorno:

int (*f)(int);   // puntatore a una funzione che prende int e restituisce int
int *g(int);     // FUNZIONE che prende int e restituisce int*: tutt'altra cosa

Ecco un esempio completo in funzione:

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    int (*op)(int, int);        // dichiara

    op = add;                   // assegna (la & non serve)
    printf("somma:          %d\n", op(10, 3));

    op = subtract;              // lo fa puntare altrove
    printf("sottrazione:    %d\n", op(10, 3));

    op = &multiply;             // la & va bene ma non serve
    printf("moltiplicazione: %d\n", (*op)(10, 3));   // come questa forma di chiamata

    printf("\nla funzione stessa si trova a %p\n", (void *)(void (*)(void))add);
    return 0;
}

Entrambe le forme di chiamata funzionano perché il nome di una funzione si converte automaticamente in un puntatore. Scrivi op(10, 3); la forma (*op)(10, 3) è un retaggio del passato.

Una nota sull'ultima printf: %p si aspetta un puntatore a oggetto, e i puntatori a funzione formalmente appartengono a una famiglia separata, quindi stamparne uno non è strettamente portabile. Il cast mette a tacere i compilatori sulle piattaforme dove funziona; ti capiterà raramente di doverne stampare uno.

typedef la rende leggibile

La sintassi della dichiarazione diventa brutta in fretta, e typedef è il rimedio standard:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = puntatore a int(int,int)

int add(int a, int b)      { return a + b; }
int multiply(int a, int b) { return a * b; }

// ora una funzione che prende una funzione si legge come qualsiasi altra dichiarazione
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

Confronta int apply(BinaryOp op, int x, int y) con la forma grezza, int apply(int (*op)(int, int), int x, int y). Stesso significato; una delle due si legge a colpo d'occhio. Vedi typedef per le regole generali.

Callback: il chiamante fornisce il comportamento

Una callback è una funzione che passi a un'altra funzione perché questa possa richiamarti al momento giusto. Permette a un pezzo di codice di gestire la struttura di un lavoro mentre il chiamante fornisce la decisione.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// una sola funzione, qualsiasi test
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("pari:      %d\n", count_if(data, n, is_even));
    printf("positivi:  %d\n", count_if(data, n, is_positive));
    printf("grandi:    %d\n", count_if(data, n, is_big));

    return 0;
}

Senza puntatori a funzione scriveresti count_even, count_positive e count_big: tre copie dello stesso ciclo. Con i puntatori, il ciclo si scrive una volta e il parametro è il test.

Il vero vantaggio: qsort

La funzione qsort della libreria standard è l'esempio di puntatore a funzione che userai davvero. Ordina un array di qualsiasi cosa, e ci riesce senza sapere nulla degli elementi tranne la loro dimensione e un comparatore che fornisci tu.

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

Il comparatore riceve due const void *, gli indirizzi di due elementi, e restituisce un numero negativo se il primo va prima del secondo, zero se sono pari, positivo se va dopo.

#include <stdio.h>
#include <stdlib.h>

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // converte al tipo reale, poi legge
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // scambiare gli argomenti inverte l'ordine
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("crescente:   ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\ndecrescente: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

Due abitudini da portarti dietro da quel comparatore. Non scrivere mai return x - y;: sembra furbo ma va in overflow con valori grandi o negativi, producendo un segno sbagliato e un array ordinato male. Fai il cast prima di dereferenziare, non dopo: *(const int *)a, perché *a su un void * non ha niente da leggere.

Lo stesso meccanismo ordina struct in base a qualsiasi campo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // prima i punteggi alti
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("per punteggio:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("per nome:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

L'idioma (q->score > p->score) - (q->score < p->score) restituisce esattamente -1, 0 o 1 senza sottrazioni e senza overflow. E strcmp ha già la convenzione di ritorno giusta, quindi un comparatore di stringhe sta in una riga.

Tabelle di puntatori a funzione

Un array di puntatori a funzione trasforma una catena di if/else in una ricerca in tabella. È così che gli interpreti smistano gli opcode e che i sistemi a menu eseguono i comandi.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "somma"},
        {'-', op_sub, "sottrai"},
        {'*', op_mul, "moltiplica"},
        {'/', op_div, "dividi"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // smista in base a un carattere, senza switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\nsmistato '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Aggiungere un'operazione ora significa aggiungere una riga, non modificare uno switch. Abbinalo alle struct e ottieni la forma standard di un plugin in C: una struct di puntatori a funzione è ciò che in questo linguaggio si intende per "interfaccia".

Cose che mordono

Le firme devono corrispondere esattamente. Il tipo di un puntatore a funzione include i tipi dei parametri e il tipo di ritorno. Assegnare una funzione con una firma diversa viola un vincolo del linguaggio, e chiamare tramite un puntatore del tipo sbagliato è comportamento indefinito anche quando "funziona". Non fare il cast della firma di un comparatore per zittire un avviso: correggi il comparatore.

Un puntatore a funzione nullo resta un puntatore nullo. Inizializzalo a NULL e controllalo prima di chiamarlo, esattamente come con i puntatori ai dati:

if (handler != NULL) {
    handler(event);
}

Vedi puntatori nulli per capire perché quel controllo vale la pena.

I puntatori void perdono la sicurezza dei tipi, e il sistema dei tipi sei tu. Dentro un comparatore di qsort, niente ti impedisce di fare il cast al tipo sbagliato. Se ordini un array di double con compare_ints, compila senza problemi e produce risultati senza senso.

La sintassi dei dichiaratori si annida. Una funzione che restituisce un puntatore a funzione si scrive int (*get_op(char c))(int, int);. Quando ti ritrovi a scrivere una cosa del genere, usa typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // la stessa cosa, ma leggibile

Domande frequenti

Come si dichiara un puntatore a funzione in C?

Scrivi la firma della funzione con (*nome) al posto del nome della funzione: int (*op)(int, int); dichiara op come puntatore a una funzione che prende due int e restituisce un int. Le parentesi attorno a *op sono obbligatorie: senza di esse dichiari una funzione che restituisce un puntatore.

Come si chiama una funzione tramite un puntatore?

Con op(3, 4) oppure con (*op)(3, 4): sono entrambe valide e fanno la stessa cosa, perché il nome di una funzione si converte automaticamente in un puntatore. Il codice C moderno usa la forma semplice op(3, 4).

Cos'è una callback in C?

Una funzione che passi a un'altra funzione perché questa possa richiamarti. qsort è l'esempio classico: gli passi un comparatore, e qsort lo chiama ogni volta che deve sapere quale di due elementi viene prima. È questo che permette a una sola routine di ordinamento di funzionare con qualsiasi tipo.

Serve la & per prendere l'indirizzo di una funzione?

No. Il nome di una funzione si converte già in un puntatore a quella funzione, quindi op = add; e op = &add; sono equivalenti. La maggior parte del codice C omette la &.

Concetti correlati