Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C

Tablas de despacho de callbacks en C

Asocia códigos de operación a punteros a función y distingue un índice inválido de una entrada válida para la que no se ha definido un callback.

Versión: ISO C23; implementation support may vary

Sintaxis

#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 tabla de despacho de callbacks asocia códigos de operación a punteros a función. typedef void (*ProcessOp)(struct Process *, size_t); da nombre al tipo de un puntero a una función que recibe struct Process * y size_t y no devuelve ningún valor (void). Si la etiqueta de estructura Process aún no es visible, declara primero struct Process; en el mismo ámbito que el typedef para que el prototipo se refiera al tipo de estructura correcto.

En el inicializador, el designador de función add se convierte implícitamente en un puntero a esa función; &show toma la dirección de forma explícita. Ambas funciones deben tener tipos compatibles con el tipo de función al que apunta ProcessOp, incluidos el tipo de retorno y los tipos de los parámetros. op(p, n) y (*op)(p, n) son llamadas indirectas equivalentes. Una conversión explícita no corrige un tipo incompatible: llamar a través del puntero convertido tiene comportamiento indefinido. ISO C no garantiza que se puedan almacenar punteros a función en void * de forma portable.

Comprueba el rango de id antes de leer ops[id], sobre todo si el código procede del exterior del programa. Luego compara el puntero leído con NULL, una macro de <stddef.h> que representa una constante de puntero nulo. Una entrada nula indica aquí que la operación no está disponible; un código fuera de rango no es válido. Tanto una lectura fuera del array como una llamada mediante un puntero nulo tienen comportamiento indefinido.

const impide asignar valores a las entradas de esta tabla, pero no modificar el objeto pasado mediante p. El puntero a función no contiene el contexto: pásalo por separado y asegúrate de que el objeto siga vivo mientras el callback lo utilice. El patrón es válido en ISO C23 y no requiere sintaxis introducida en C23; la compatibilidad con C23 depende de la implementación.

Ejemplos

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

Resultado

total=5
unsupported operation
invalid operation id

`OP_ADD` cambia `total` de 2 a 5 y `OP_SHOW` imprime el resultado. `OP_RESERVED` está dentro del rango, pero contiene `NULL`; `-1` se rechaza antes de leer la tabla.

Lecciones relacionadas

  • C · Lección 85 · Avanzado · Versión: 3

Fuentes