Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Dichiaratori di puntatori a funzione e callback di confronto in C

Dichiara un tipo puntatore a funzione, passa un comparatore compatibile e confronta priorità senza overflow, anche agli estremi del tipo `int`.

Versione: ISO C23; implementation support may vary

Sintassi

/* Process is a previously declared type. */
typedef int (*ProcessCmp)(const Process *, const Process *);

/* Callback parameter using the typedef or the equivalent explicit declarator. */
int apply_cmp(const Process *a, const Process *b, ProcessCmp cmp);
int apply_cmp(const Process *a, const Process *b,
              int (*cmp)(const Process *, const Process *));

/* Equivalent calls inside apply_cmp. */
cmp(a, b)
(*cmp)(a, b)

typedef int (*ProcessCmp)(const Process *, const Process *); assegna il nome ProcessCmp al tipo del puntatore, non a quello della funzione. La funzione accetta due puntatori a const Process e restituisce un int. Le parentesi attorno a *ProcessCmp sono essenziali: int (*f)(...) dichiara un puntatore a una funzione che restituisce int, mentre int *f(...) dichiara una funzione che restituisce int *. Qui ... rappresenta un elenco di parametri omesso.

apply_cmp accetta un parametro ProcessCmp cmp. Passando by_priority, il designatore della funzione viene convertito implicitamente in un puntatore; si può usare anche &by_priority. In apply_cmp, cmp(a, b) e (*cmp)(a, b) sono equivalenti. Passa un puntatore non nullo a una funzione di tipo compatibile e puntatori a oggetti Process che rimangano in vita per tutta la chiamata. Un cast non rende valida una chiamata tramite un tipo di funzione incompatibile: il comportamento è indefinito.

Il contratto del comparatore si basa sul segno del risultato: negativo se la prima chiave è minore, zero se le chiavi sono uguali, positivo se la prima è maggiore. INT_MIN e INT_MAX, definiti in <limits.h>, sono i valori minimo e massimo di int. Confrontare con x - y può causare un overflow di int con segno, con comportamento indefinito. Invece (x > y) - (x < y) sottrae solo risultati dei confronti di tipo int pari a 0 o 1 e produce quindi -1, 0 o 1 anche agli estremi.

Il meno unario in -r inverte il segno. È sicuro per un risultato normalizzato a -1, 0 o 1, ma un comparatore qualsiasi può restituire INT_MIN, la cui negazione ha comportamento indefinito in C23. Per invertire l’ordine senza negare il risultato, scambia gli argomenti: cmp(b, a). La sintassi è valida in ISO C23; il supporto per C23 può variare a seconda dell’implementazione.

Esempi

#include <limits.h>
#include <stdio.h>

typedef struct {
    int priority;
} Process;

typedef int (*ProcessCmp)(const Process *, const Process *);

static int by_priority(const Process *a, const Process *b)
{
    return (a->priority > b->priority) - (a->priority < b->priority);
}

static int apply_cmp(const Process *a, const Process *b, ProcessCmp cmp)
{
    return cmp(a, b);
}

int main(void)
{
    const Process low = { INT_MIN };
    const Process high = { INT_MAX };
    const Process same = { INT_MIN };

    int ascending = apply_cmp(&low, &high, by_priority);
    int equal = apply_cmp(&low, &same, by_priority);
    int greater = apply_cmp(&high, &low, by_priority);
    int reversed = -ascending;

    printf("%d %d %d\n%d\n", ascending, equal, greater, reversed);
    return 0;
}

Risultato

-1 0 1
1

La prima riga mostra nell’ordine una priorità minore, uguale e maggiore. La seconda mostra il risultato del confronto «minore di» con il segno invertito. Le priorità uguali appartengono a due oggetti distinti.

Lezioni correlate

  • C · Lezione 76 · Avanzato · Versione: 3

Fonti