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

CKTIS / C

Callbacks em C: ponteiros para funções com `typedef`

Dá um nome a um tipo ponteiro para função para passar estratégias e predicados, devolver a função escolhida ou guardar callbacks em estruturas e arrays.

Versão: ISO C23; implementation support may vary

Sintaxe

typedef double (*PricingFn)(double);
typedef double PricingFunc(double); /* PricingFunc * is equivalent to PricingFn */

typedef struct Order Order;
typedef int (*OrderPred)(const Order *);
typedef int (*OrderCmp)(const Order *, const Order *);

double add_fee(double);
double double_price(double);
double apply_price(double base, PricingFn fn);
PricingFn select_rule(int use_double);
void apply_rules(PricingFn rules[], size_t n); /* include <stddef.h> for size_t */

typedef struct {
    PricingFn price;
} InvoiceProcessor;

/* Inside a function, with add_fee and double_price declared: */
PricingFn fn = add_fee;
PricingFn rules[] = {add_fee, &double_price};
InvoiceProcessor processor = {fn};

typedef double (*PricingFn)(double); dá o nome PricingFn ao tipo ponteiro para uma função que recebe um double e devolve um double. É um alias, não um tipo novo nem uma função. Os parênteses em torno de *PricingFn são importantes. Já typedef double PricingFunc(double); dá nome ao tipo da função; PricingFunc * é equivalente a PricingFn.

Em PricingFn fn = add_fee; e na passagem como argumento, o nome da função add_fee é convertido num ponteiro; &add_fee também funciona. fn(base) e (*fn)(base) fazem a mesma chamada indireta. Uma função de seleção pode devolver um PricingFn sem chamar a função escolhida. Podes depois substituir o ponteiro numa variável ou guardá-lo num campo de uma estrutura e chamar p->price(base).

PricingFn rules[] pode declarar um array de ponteiros para funções; rules[i](base) chama a função no índice i. Numa declaração de parâmetro, PricingFn rules[] é ajustado para PricingFn *: passa o comprimento em separado e respeita os limites. Para um array dinâmico de n > 0 elementos, usa PricingFn *items = malloc(n * sizeof *items); com <stdlib.h> depois de verificares que o produto cabe em size_t. Trata NULL, atribui um ponteiro válido a cada posição usada e, no fim, chama free(items). Isso liberta o array, não as funções.

OrderPred recebe um const Order *: zero significa falso e qualquer valor diferente de zero significa verdadeiro. Com um predicado válido, count_if chama pred(&orders[i]) uma vez por elemento. OrderCmp recebe dois const Order *; um comparador devolve normalmente um valor negativo, zero ou um valor positivo se o primeiro elemento for menor, igual ou maior do que o segundo, respetivamente.

Faz chamadas apenas através de um ponteiro inicializado e não nulo para uma função com tipos de parâmetros e de retorno compatíveis. Chamar através de NULL ou de um ponteiro para um tipo de função incompatível tem comportamento indefinido; uma conversão explícita não corrige a incompatibilidade. void * não é um substituto portável para um ponteiro para função. Estas construções são anteriores ao ISO C23; o suporte do modo C23 varia consoante a implementação.

Exemplos

#include <stdio.h>

typedef double (*PricingFn)(double);

typedef struct {
    int total;
} Order;
typedef int (*OrderPred)(const Order *);

typedef struct {
    PricingFn price;
} InvoiceProcessor;

static double add_fee(double base) { return base + 2.0; }
static double double_price(double base) { return base * 2.0; }
static int is_large(const Order *order) { return order->total >= 10; }

static double apply_price(double base, PricingFn fn)
{
    return fn(base); /* Caller must supply a valid callback. */
}

static PricingFn select_rule(int use_double)
{
    return use_double ? double_price : add_fee;
}

static size_t count_if(const Order orders[], size_t n, OrderPred pred)
{
    size_t matches = 0;
    if (pred == NULL)
        return 0;
    for (size_t i = 0; i < n; ++i)
        if (pred(&orders[i]))
            ++matches;
    return matches;
}

int main(void)
{
    PricingFn fn = select_rule(0);
    printf("strategy: %.0f\n", apply_price(10.0, fn));

    PricingFn rules[] = {add_fee, &double_price};
    fn = rules[1];
    InvoiceProcessor processor = {fn};
    const InvoiceProcessor *p = &processor;
    printf("switched: %.0f\n", p->price(10.0));

    const Order orders[] = {{7}, {10}, {24}};
    printf("matches: %zu\n",
           count_if(orders, sizeof orders / sizeof orders[0], is_large));
    return 0;
}

Resultado

strategy: 12
switched: 20
matches: 2

`select_rule(0)` escolhe `add_fee`. Depois, `rules[1]` fornece `double_price`, chamada através de um campo da estrutura. `count_if` encontra duas encomendas que satisfazem o predicado; neste exemplo, a ausência do predicado (`NULL`) dá uma contagem de zero.

Lições relacionadas

  • C · Lição 39 · Intermédio · Versão: 3
  • C · Lição 40 · Intermédio · Versão: 3
  • C · Lição 41 · Intermédio · Versão: 3
  • C · Lição 42 · Intermédio · Versão: 3
  • C · Lição 43 · Intermédio · Versão: 3
  • C · Lição 44 · Intermédio · Versão: 3
  • C · Lição 45 · Intermédio · Versão: 3
  • C · Lição 47 · Intermédio · Versão: 3
  • C · Lição 48 · Intermédio · Versão: 3

Fontes