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

CKTIS / C

Declaradores de punteros a función y comparadores como callbacks en C

Declara un tipo de puntero a función, pasa un comparador compatible y compara prioridades sin desbordamiento, incluso en los límites de `int`.

Versión: ISO C23; implementation support may vary

Sintaxis

/* Process is a previously declared type. */
typedef int (*ProcessCmp)(const Process *, const Process *);

/* Callback parameter using the typedef or the equivalent explicit declarator. */
int apply_cmp(const Process *a, const Process *b, ProcessCmp cmp);
int apply_cmp(const Process *a, const Process *b,
              int (*cmp)(const Process *, const Process *));

/* Equivalent calls inside apply_cmp. */
cmp(a, b)
(*cmp)(a, b)

typedef int (*ProcessCmp)(const Process *, const Process *); da el nombre ProcessCmp al tipo del puntero, no al de la función. La función recibe dos punteros a const Process y devuelve un int. Los paréntesis alrededor de *ProcessCmp son esenciales: int (*f)(...) declara un puntero a una función que devuelve int, mientras que int *f(...) declara una función que devuelve int *. Aquí ... representa una lista de parámetros omitida.

apply_cmp recibe un parámetro ProcessCmp cmp. Al pasar by_priority, el designador de la función se convierte implícitamente en un puntero; también sirve &by_priority. Dentro de apply_cmp, cmp(a, b) y (*cmp)(a, b) son equivalentes. Pasa un puntero no nulo a una función de tipo compatible y punteros a objetos Process que sigan vivos durante toda la llamada. Una conversión explícita no hace válida una llamada a través de un tipo de función incompatible: el comportamiento es indefinido.

El contrato del comparador se basa en el signo: un valor negativo indica que la primera clave es menor, cero indica que las claves son iguales y un valor positivo indica que la primera es mayor. INT_MIN e INT_MAX, de <limits.h>, son el menor y el mayor valor de int. Comparar mediante x - y puede desbordar un int con signo, lo que causa comportamiento indefinido. En cambio, (x > y) - (x < y) solo resta resultados de comparaciones de tipo int que valen 0 o 1, por lo que produce -1, 0 o 1 incluso en los extremos.

El menos unario de -r invierte el signo. Es seguro si el resultado se ha normalizado a -1, 0 o 1, pero un comparador cualquiera puede devolver INT_MIN, cuya negación tiene comportamiento indefinido en C23. Para invertir el orden sin negar el resultado, intercambia los argumentos: cmp(b, a). La sintaxis es válida en ISO C23; la compatibilidad con C23 puede variar según la implementación.

Ejemplos

#include <limits.h>
#include <stdio.h>

typedef struct {
    int priority;
} Process;

typedef int (*ProcessCmp)(const Process *, const Process *);

static int by_priority(const Process *a, const Process *b)
{
    return (a->priority > b->priority) - (a->priority < b->priority);
}

static int apply_cmp(const Process *a, const Process *b, ProcessCmp cmp)
{
    return cmp(a, b);
}

int main(void)
{
    const Process low = { INT_MIN };
    const Process high = { INT_MAX };
    const Process same = { INT_MIN };

    int ascending = apply_cmp(&low, &high, by_priority);
    int equal = apply_cmp(&low, &same, by_priority);
    int greater = apply_cmp(&high, &low, by_priority);
    int reversed = -ascending;

    printf("%d %d %d\n%d\n", ascending, equal, greater, reversed);
    return 0;
}

Resultado

-1 0 1
1

La primera línea muestra, por orden, una prioridad menor, igual y mayor. La segunda muestra el resultado de la comparación «menor que» con el signo invertido. Las prioridades iguales pertenecen a dos objetos distintos.

Lecciones relacionadas

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

Fuentes