Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C

Tables de répartition de fonctions de rappel en C

Associez des identifiants d’opération à des pointeurs de fonction, puis distinguez un indice invalide d’une entrée valide sans fonction de rappel.

Version : ISO C23; implementation support may vary

Syntaxe

#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); */

Une table de répartition de fonctions de rappel associe des identifiants d’opération à des pointeurs de fonction. typedef void (*ProcessOp)(struct Process *, size_t); nomme le type d’un pointeur vers une fonction qui reçoit struct Process * et size_t et ne renvoie aucune valeur (void). Si l’étiquette de structure Process n’est pas encore visible, déclarez d’abord struct Process; dans la même portée que le typedef pour que le prototype désigne le bon type de structure.

Dans l’initialiseur, le désignateur de fonction add est implicitement converti en pointeur vers cette fonction ; &show en prend explicitement l’adresse. Les deux fonctions doivent avoir un type compatible avec le type de fonction pointé par ProcessOp, y compris le type de retour et les types des paramètres. op(p, n) et (*op)(p, n) sont deux formes équivalentes d’appel indirect. Un transtypage ne corrige pas un type incompatible : un tel appel a un comportement indéfini. ISO C ne garantit pas le stockage portable de pointeurs de fonction dans void *.

Vérifiez les bornes de id avant de lire ops[id], surtout si l’identifiant vient de l’extérieur du programme. Comparez ensuite le pointeur lu à NULL, une macro de <stddef.h> qui représente une constante de pointeur nul. Une entrée nulle indique ici une opération non prise en charge ; un identifiant hors limites est invalide. Une lecture hors du tableau et un appel par un pointeur nul ont tous deux un comportement indéfini.

const interdit les affectations aux entrées de cette table, mais n’empêche pas de modifier l’objet transmis via p. Le pointeur de fonction ne contient pas le contexte : transmettez-le séparément et veillez à ce que l’objet reste vivant tant que la fonction de rappel l’utilise. Ce modèle est valide en ISO C23 et ne requiert aucune syntaxe introduite dans C23 ; la prise en charge de C23 dépend de l’implémentation.

Exemples

#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;
}

Résultat

total=5
unsupported operation
invalid operation id

`OP_ADD` fait passer `total` de 2 à 5, et `OP_SHOW` affiche le résultat. `OP_RESERVED` est dans les limites, mais contient `NULL` ; `-1` est rejeté avant tout accès à la table.

Leçons associées

  • C · Leçon 85 · Avancé · Version : 3

Sources