Docs ejecutables de C: Punteros a funciones

Q: ¿Cómo se declara un puntero a función en C?

Escribe la firma de la función con (nombre) donde iría el nombre de la función: int (op)(int, int); declara op como un puntero a una función que toma dos int y devuelve int. Los paréntesis alrededor de *op son obligatorios: sin ellos declaras una función que devuelve un puntero.

Q: ¿Cómo se llama a una función a través de un puntero?

Con op(3, 4) o con (*op)(3, 4): ambas formas son legales y hacen lo mismo, porque un designador de función se convierte a puntero automáticamente. El código C moderno usa la forma simple op(3, 4).

El código compilado vive en memoria igual que los datos, así que una función tiene una dirección. Un puntero a función es una variable que guarda una, y en cuanto puedes guardar una función puedes pasarla como argumento, mantener una tabla de ellas o elegir entre varias en tiempo de ejecución.

Esa es la capacidad detrás de ordenar con un criterio propio, los manejadores de eventos, las interfaces de plugins y las máquinas de estados. También es la parte de la sintaxis de C que más probablemente hace que un lector se detenga y entrecierre los ojos, así que empezamos por ahí.

La sintaxis de la declaración

Toma una función corriente:

int add(int a, int b);

Para declarar un puntero que pueda guardar su dirección, reemplaza el nombre por (*nombre):

int (*op)(int, int);

Léelo de dentro hacia afuera: op es un puntero, a una función, que toma (int, int) y devuelve int.

Los paréntesis no son decoración. Sin ellos, el * se asocia al tipo de retorno:

int (*f)(int);   // puntero a una funcion que toma int y devuelve int
int *g(int);     // FUNCION que toma int y devuelve int* - completamente distinto

Aquí está funcionando de punta a punta:

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    int (*op)(int, int);        // declarar

    op = add;                   // asignar (sin necesidad de &)
    printf("suma:           %d\n", op(10, 3));

    op = subtract;              // apuntarlo a otro lado
    printf("resta:          %d\n", op(10, 3));

    op = &multiply;             // el & se permite pero sobra
    printf("multiplicacion: %d\n", (*op)(10, 3));   // esta forma de llamada tambien

    printf("\nla funcion misma vive en %p\n", (void *)(void (*)(void))add);
    return 0;
}

Ambas formas de llamada funcionan porque un designador de función se convierte a puntero automáticamente. Escribe op(10, 3); la grafía (*op)(10, 3) es una reliquia.

Una nota sobre ese último printf: %p espera un puntero a objeto, y los punteros a función son formalmente otra familia, así que imprimir uno no es estrictamente portable. La conversión mantiene callados a los compiladores en las plataformas donde funciona; rara vez necesitarás imprimir uno.

typedef lo vuelve legible

La sintaxis de la declaración se pone fea rápido, y typedef es el remedio estándar:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = puntero a int(int,int)

int add(int a, int b)      { return a + b; }
int multiply(int a, int b) { return a * b; }

// ahora una funcion que toma una funcion se lee como cualquier otra declaracion
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

Compara int apply(BinaryOp op, int x, int y) con la forma cruda, int apply(int (*op)(int, int), int x, int y). El mismo significado; una de las dos se lee de un vistazo. Mira typedef para las reglas generales.

Callbacks: dejar que quien llama aporte el comportamiento

Un callback es una función que le entregas a otra función para que te llame de vuelta en el momento adecuado. Permite que una parte del código se encargue de la estructura de un trabajo mientras quien llama aporta la decisión.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// una sola funcion, cualquier prueba
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("pares:      %d\n", count_if(data, n, is_even));
    printf("positivos:  %d\n", count_if(data, n, is_positive));
    printf("grandes:    %d\n", count_if(data, n, is_big));

    return 0;
}

Sin punteros a funciones escribirías count_even, count_positive y count_big: tres copias del mismo bucle. Con ellos, el bucle se escribe una vez y la prueba es el parámetro.

La recompensa de verdad: qsort

El qsort de la biblioteca estándar es el ejemplo de punteros a funciones que de verdad vas a usar. Ordena un array de lo que sea, y lo logra sin saber nada de los elementos salvo su tamaño y un comparador que tú proporcionas.

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

El comparador recibe dos const void * —las direcciones de dos elementos— y devuelve un número negativo si el primero va antes que el segundo, cero si empatan y positivo si va después.

#include <stdio.h>
#include <stdlib.h>

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // convertir al tipo real y luego leer
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // intercambiar los argumentos invierte el orden
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("ascendente:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\ndescendente: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

Dos hábitos que llevarse de ese comparador. Nunca escribas return x - y;: parece ingenioso y se desborda con valores grandes o negativos, produciendo un signo equivocado y un array mal ordenado. Convierte antes de desreferenciar, no después: *(const int *)a, porque *a sobre un void * no tiene nada que leer.

La misma maquinaria ordena estructuras por el campo que quieras:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // mayor primero
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("por puntaje:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("por nombre:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

El modismo (q->score > p->score) - (q->score < p->score) devuelve exactamente -1, 0 o 1 sin restas y sin desbordamiento. Y strcmp ya tiene la convención de retorno correcta, así que un comparador de cadenas cabe en una línea.

Tablas de punteros a funciones

Un array de punteros a funciones convierte una cadena de if/else en una búsqueda. Así es como los intérpretes despachan opcodes y como los sistemas de menús ejecutan comandos.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "sumar"},
        {'-', op_sub, "restar"},
        {'*', op_mul, "multiplicar"},
        {'/', op_div, "dividir"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // despachar segun un caracter, sin un switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\ndespachado '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Agregar una operación ahora es agregar una fila, no editar un switch. Combina eso con estructuras y tienes la forma estándar de un plugin en C: una estructura de punteros a funciones es lo que significa "una interfaz" en este lenguaje.

Cosas que muerden

Las firmas deben coincidir exactamente. El tipo de un puntero a función incluye los tipos de sus parámetros y su tipo de retorno. Asignar una función que no coincide es una violación de restricción, y llamar a través de un puntero con el tipo equivocado es comportamiento indefinido incluso cuando "funciona". No conviertas la firma de un comparador para callar un aviso: arregla el comparador.

Un puntero a función nulo sigue siendo un puntero nulo. Inicialízalo a NULL y compruébalo antes de llamar, exactamente igual que con los punteros a datos:

if (handler != NULL) {
    handler(event);
}

Mira punteros nulos para entender por qué esa comprobación se gana su lugar.

Los punteros a void pierden la seguridad de tipos, y el sistema de tipos eres tú. Dentro de un comparador de qsort, nada te impide convertir al tipo equivocado. Si ordenas un array de double con compare_ints, compila sin quejas y produce disparates.

La sintaxis de los declaradores se anida. Una función que devuelve un puntero a función es int (*get_op(char c))(int, int);. Cuando te descubras escribiendo eso, recurre a typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // lo mismo, pero legible

Preguntas frecuentes

¿Cómo se declara un puntero a función en C?

Escribe la firma de la función con (*nombre) donde iría el nombre de la función: int (*op)(int, int); declara op como un puntero a una función que toma dos int y devuelve int. Los paréntesis alrededor de *op son obligatorios: sin ellos declaras una función que devuelve un puntero.

¿Cómo se llama a una función a través de un puntero?

Con op(3, 4) o con (*op)(3, 4): ambas formas son legales y hacen lo mismo, porque un designador de función se convierte a puntero automáticamente. El código C moderno usa la forma simple op(3, 4).

¿Qué es un callback en C?

Una función que le entregas a otra función para que te llame de vuelta. qsort es el ejemplo clásico: le pasas un comparador, y qsort lo llama cada vez que necesita saber cuál de dos elementos va primero. Eso es lo que permite que una sola rutina de ordenamiento funcione con cualquier tipo.

¿Hace falta el & para tomar la dirección de una función?

No. El nombre de una función ya se convierte en un puntero a esa función, así que op = add; y op = &add; son equivalentes. La mayoría del código C omite el &.

Conceptos relacionados