Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Tabelle di dispatch delle callback in C

Associa i codici operazione a puntatori a funzione e distingui un indice non valido da una voce valida ma priva di una callback.

Versione: ISO C23; implementation support may vary

Sintassi

#include <stddef.h>

struct Process;
typedef void (*ProcessOp)(struct Process *, size_t);

enum { OP_ADD, OP_SHOW, OP_RESERVED, OP_COUNT };
static void add(struct Process *, size_t);
static void show(struct Process *, size_t);

static ProcessOp const ops[OP_COUNT] = {
    [OP_ADD] = add,
    [OP_SHOW] = &show,
    [OP_RESERVED] = NULL,
};

/* Inside a function with parameters id, p, and n: */
/* if (id >= 0 && id < OP_COUNT && ops[id] != NULL)
       ops[id](p, n); */

Una tabella di dispatch delle callback associa i codici operazione a puntatori a funzione. typedef void (*ProcessOp)(struct Process *, size_t); dà un nome al tipo di un puntatore a una funzione che accetta struct Process * e size_t e non restituisce alcun valore (void). Se il tag della struttura Process non è ancora visibile, dichiara prima struct Process; nello stesso ambito del typedef, così il prototipo si riferisce al tipo di struttura corretto.

Nell’inizializzatore, il designatore di funzione add viene convertito implicitamente in un puntatore a quella funzione; &show ne prende esplicitamente l’indirizzo. Entrambe le funzioni devono avere un tipo compatibile con il tipo di funzione a cui punta ProcessOp, compresi il tipo di ritorno e i tipi dei parametri. op(p, n) e (*op)(p, n) sono chiamate indirette equivalenti. Un cast non corregge un tipo incompatibile: chiamare tramite il puntatore convertito ha comportamento indefinito. ISO C non garantisce che si possano memorizzare puntatori a funzione in void * in modo portabile.

Controlla l’intervallo di id prima di leggere ops[id], soprattutto se il codice proviene dall’esterno del programma. Confronta poi il puntatore letto con NULL, una macro di <stddef.h> che rappresenta una costante puntatore nullo. Una voce nulla indica qui un’operazione non supportata; un codice fuori intervallo non è valido. Sia la lettura fuori dai limiti dell’array sia la chiamata tramite un puntatore nullo hanno comportamento indefinito.

const impedisce assegnazioni alle voci di questa tabella, non modifiche all’oggetto passato tramite p. Il puntatore a funzione non contiene il contesto: passalo separatamente e assicurati che l’oggetto rimanga in vita finché la callback lo usa. Lo schema è valido in ISO C23 e non richiede sintassi introdotta in C23; il supporto di C23 varia a seconda dell’implementazione.

Esempi

#include <stddef.h>
#include <stdio.h>

struct Process {
    size_t total;
};

typedef void (*ProcessOp)(struct Process *, size_t);

enum { OP_ADD, OP_SHOW, OP_RESERVED, OP_COUNT };
enum DispatchResult { DISPATCH_OK, DISPATCH_BAD_ID, DISPATCH_UNSUPPORTED };

static void add(struct Process *p, size_t n)
{
    p->total += n;
}

static void show(struct Process *p, size_t n)
{
    (void)n;
    printf("total=%zu\n", p->total);
}

static ProcessOp const ops[OP_COUNT] = {
    [OP_ADD] = add,
    [OP_SHOW] = &show,
    [OP_RESERVED] = NULL,
};

static enum DispatchResult dispatch(int id, struct Process *p, size_t n)
{
    if (id < 0 || id >= OP_COUNT) {
        return DISPATCH_BAD_ID;
    }

    ProcessOp op = ops[id];
    if (op == NULL) {
        return DISPATCH_UNSUPPORTED;
    }

    op(p, n);
    return DISPATCH_OK;
}

int main(void)
{
    struct Process p = { .total = 2 };
    if (dispatch(OP_ADD, &p, 3) != DISPATCH_OK ||
        dispatch(OP_SHOW, &p, 0) != DISPATCH_OK) {
        return 1;
    }
    if (dispatch(OP_RESERVED, &p, 0) == DISPATCH_UNSUPPORTED) {
        puts("unsupported operation");
    }
    if (dispatch(-1, &p, 0) == DISPATCH_BAD_ID) {
        puts("invalid operation id");
    }
    return 0;
}

Risultato

total=5
unsupported operation
invalid operation id

`OP_ADD` porta `total` da 2 a 5 e `OP_SHOW` stampa il risultato. `OP_RESERVED` rientra nell’intervallo ma contiene `NULL`; `-1` viene respinto prima di leggere la tabella.

Lezioni correlate

  • C · Lezione 85 · Avanzato · Versione: 3

Fonti