Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C

Tabelas de despacho de callbacks em C

Associe códigos de operação a ponteiros para funções e distinga um índice inválido de uma entrada válida sem uma função de retorno de chamada.

Versão: ISO C23; implementation support may vary

Sintaxe

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

Uma tabela de despacho de callbacks associa códigos de operação a ponteiros para funções. typedef void (*ProcessOp)(struct Process *, size_t); dá um nome ao tipo de um ponteiro para uma função que recebe struct Process * e size_t e não devolve qualquer valor (void). Se a etiqueta da estrutura Process ainda não estiver visível, declare primeiro struct Process; no mesmo âmbito do typedef, para que o protótipo se refira ao tipo de estrutura pretendido.

No inicializador, o designador de função add é convertido implicitamente num ponteiro para essa função; &show obtém o endereço explicitamente. Ambas as funções têm de ter tipos compatíveis com o tipo de função para o qual ProcessOp aponta, incluindo o tipo de retorno e os tipos dos parâmetros. op(p, n) e (*op)(p, n) são chamadas indiretas equivalentes. Uma conversão explícita não corrige um tipo incompatível: chamar através do ponteiro convertido tem comportamento indefinido. O ISO C não garante que seja possível guardar ponteiros para funções em void * de forma portável.

Verifique o intervalo de id antes de ler ops[id], sobretudo se o código vier do exterior do programa. Depois, compare o ponteiro lido com NULL, uma macro de <stddef.h> que representa uma constante de ponteiro nulo. Neste caso, uma entrada nula indica que a operação não é suportada; um código fora do intervalo é inválido. Tanto a leitura fora dos limites do vetor como a chamada através de um ponteiro nulo têm comportamento indefinido.

const impede atribuições às entradas desta tabela, mas não impede alterações ao objeto passado através de p. O ponteiro para a função não contém o contexto: passe-o em separado e garanta que o objeto continua a existir enquanto a callback o utilizar. O padrão é válido em ISO C23 e não requer sintaxe introduzida em C23; o suporte de C23 varia consoante a implementação.

Exemplos

#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` altera `total` de 2 para 5 e `OP_SHOW` escreve o resultado. `OP_RESERVED` está dentro do intervalo, mas contém `NULL`; `-1` é rejeitado antes de a tabela ser lida.

Lições relacionadas

  • C · Lição 85 · Avançado · Versão: 3

Fontes