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

CKTIS / C

Callbacks en C: punteros a función con `typedef`

Pon nombre a un tipo puntero a función para pasar estrategias y predicados, devolver la función elegida o guardar callbacks en estructuras y arrays para invocarlos más tarde.

Versión: ISO C23; implementation support may vary

Sintaxis

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); da el nombre PricingFn al tipo puntero a una función que recibe un double y devuelve un double. Es un alias, no un tipo nuevo ni una función. Los paréntesis alrededor de *PricingFn importan. En cambio, typedef double PricingFunc(double); nombra el tipo de función; PricingFunc * equivale a PricingFn.

En PricingFn fn = add_fee; y al pasarlo como argumento, el nombre de función add_fee se convierte en puntero; &add_fee también sirve. fn(base) y (*fn)(base) realizan la misma llamada indirecta. Una función selectora puede devolver un PricingFn sin llamar a la función elegida. Luego puedes sustituir el puntero en una variable o guardarlo en un campo de estructura y llamar con p->price(base).

PricingFn rules[] puede declarar un array de punteros a función; rules[i](base) llama a la función del índice i. En una declaración de parámetro, PricingFn rules[] se ajusta a PricingFn *: pasa la longitud por separado y respeta los límites. Para un array dinámico de n > 0 elementos, usa PricingFn *items = malloc(n * sizeof *items); con <stdlib.h> tras comprobar que el producto cabe en size_t. Gestiona NULL, asigna un puntero válido a cada posición que uses y llama a free(items) al terminar. Así se libera el array, no las funciones.

OrderPred recibe un const Order *: cero significa falso y cualquier valor distinto de cero, verdadero. Con un predicado válido, count_if llama a pred(&orders[i]) una vez por elemento. OrderCmp recibe dos const Order *; un comparador suele devolver un valor negativo, cero o un valor positivo si el primer elemento es menor, igual o mayor que el segundo, respectivamente.

Llama solo mediante un puntero inicializado y no nulo a una función cuyos tipos de parámetros y de retorno sean compatibles. Llamar mediante NULL o un puntero a un tipo de función incompatible tiene comportamiento indefinido; una conversión explícita no arregla la incompatibilidad. void * no es un sustituto portable de un puntero a función. Estas construcciones son anteriores a ISO C23; la compatibilidad con el modo C23 depende de la implementación.

Ejemplos

#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)` elige `add_fee`. Después, `rules[1]` proporciona `double_price`, que se invoca mediante un campo de estructura. `count_if` encuentra dos pedidos que cumplen la condición; en este ejemplo, un predicado ausente (`NULL`) da un recuento de cero.

Lecciones relacionadas

  • C · Lección 39 · Intermedio · Versión: 3
  • C · Lección 40 · Intermedio · Versión: 3
  • C · Lección 41 · Intermedio · Versión: 3
  • C · Lección 42 · Intermedio · Versión: 3
  • C · Lección 43 · Intermedio · Versión: 3
  • C · Lección 44 · Intermedio · Versión: 3
  • C · Lección 45 · Intermedio · Versión: 3
  • C · Lección 47 · Intermedio · Versión: 3
  • C · Lección 48 · Intermedio · Versión: 3

Fuentes