CKTIS / C
Callbacks kiezen met een dispatchtabel in C
Koppel operatiecodes aan functiepointers en maak bij een indirecte aanroep onderscheid tussen een ongeldige index en een geldig item zonder callback.
Versie: ISO C23; implementation support may vary
Syntax
#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); */Een dispatchtabel voor callbacks koppelt operatiecodes aan functiepointers. typedef void (*ProcessOp)(struct Process *, size_t); geeft een naam aan het type van een pointer naar een functie die struct Process * en size_t aanneemt en geen waarde teruggeeft (void). Als de struct-tag Process nog niet zichtbaar is, declareer dan eerst struct Process; in hetzelfde bereik als de typedef, zodat het prototype naar het bedoelde structtype verwijst.
In de initialisatie wordt de functieaanduiding add impliciet omgezet in een pointer naar die functie; &show neemt expliciet het adres. Beide functies moeten een type hebben dat compatibel is met het functietype waarnaar ProcessOp wijst, met inbegrip van het retourtype en de parametertypen. op(p, n) en (*op)(p, n) zijn gelijkwaardige indirecte aanroepen. Een cast lost een incompatibel type niet op: aanroepen via de geconverteerde pointer heeft ongedefinieerd gedrag. ISO C garandeert niet dat functiepointers portabel in void * kunnen worden opgeslagen.
Controleer het bereik van id voordat je ops[id] leest, vooral als de code van buiten het programma komt. Vergelijk de opgehaalde pointer daarna met NULL, een macro uit <stddef.h> die een nullpointerconstante voorstelt. Een item met een nullpointer staat hier voor een niet-ondersteunde operatie; een code buiten het bereik is ongeldig. Zowel lezen buiten de grenzen van de array als aanroepen via een nullpointer heeft ongedefinieerd gedrag.
const voorkomt toewijzingen aan de tabelitems, maar geen wijzigingen aan het via p doorgegeven object. De functiepointer bevat geen context: geef die apart door en zorg dat het object blijft bestaan zolang de callback het gebruikt. Dit patroon is geldig in ISO C23 en gebruikt geen syntaxis die pas in C23 is ingevoerd; de ondersteuning voor C23 verschilt per implementatie.
Voorbeelden
#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;
}
Resultaat
total=5 unsupported operation invalid operation id
`OP_ADD` verandert `total` van 2 in 5 en `OP_SHOW` drukt het resultaat af. `OP_RESERVED` ligt binnen het bereik maar bevat `NULL`; `-1` wordt afgewezen voordat de tabel wordt gelezen.
Gerelateerde lessen
- C · Les 85 · Gevorderd · Versie: 3