Ponteiros para função em C: sintaxe, callbacks e qsort

Código compilado mora na memória assim como os dados, então uma função tem um endereço. Um ponteiro para função é uma variável que guarda um desses endereços - e uma vez que você consegue guardar uma função, pode passá-la como argumento, manter uma tabela delas, ou escolher entre elas em tempo de execução.

É essa a capacidade por trás de ordenar com uma ordem personalizada, de tratadores de eventos, de interfaces de plugin e de máquinas de estados. Também é a parte da sintaxe de C mais propensa a fazer um leitor parar e apertar os olhos, então começamos por ela.

A sintaxe da declaração

Pegue uma função comum:

int add(int a, int b);

Para declarar um ponteiro que pode guardar o endereço dela, troque o nome por (*nome):

int (*op)(int, int);

Leia de dentro para fora: op é um ponteiro, para uma função, que recebe (int, int), retornando int.

Os parênteses não são decoração. Sem eles, o * se liga ao tipo de retorno:

int (*f)(int);   // ponteiro para uma função que recebe int e retorna int
int *g(int);     // FUNÇÃO que recebe int e retorna int* - completamente diferente

Aqui está ele funcionando de ponta a ponta:

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

    op = add;                   // atribui (sem precisar de &)
    printf("soma:       %d\n", op(10, 3));

    op = subtract;              // aponta para outro lugar
    printf("subtracao:  %d\n", op(10, 3));

    op = &multiply;             // o & e permitido, mas redundante
    printf("multiplica: %d\n", (*op)(10, 3));   // esta forma de chamada tambem

    printf("\na propria funcao mora em %p\n", (void *)(void (*)(void))add);
    return 0;
}

As duas formas de chamada funcionam porque um designador de função converte-se automaticamente para um ponteiro. Escreva op(10, 3); a grafia (*op)(10, 3) é um resquício.

Uma observação sobre aquele último printf: %p espera um ponteiro para objeto, e ponteiros para função são formalmente uma família separada, então imprimir um não é estritamente portável. O cast mantém os compiladores quietos nas plataformas em que aquilo funciona; você raramente vai precisar imprimir um.

typedef torna isso legível

A sintaxe de declaração fica feia rápido, e typedef é o remédio padrão:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = ponteiro para int(int,int)

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

// agora uma funcao que recebe uma funcao se le como qualquer outra declaracao
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;
}

Compare int apply(BinaryOp op, int x, int y) com a forma crua, int apply(int (*op)(int, int), int x, int y). Mesmo significado; uma delas você consegue ler num relance. Veja typedef para as regras gerais.

Callbacks: deixar quem chama fornecer o comportamento

Um callback é uma função que você entrega a outra função para que ela possa chamá-lo de volta no momento certo. Isso deixa um pedaço de código cuidar da estrutura de um trabalho enquanto quem chama fornece a decisão.

#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; }

// uma funcao, qualquer teste
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;
}

Sem ponteiros para função você escreveria count_even, count_positive e count_big - três cópias do mesmo laço. Com eles, o laço é escrito uma vez e o teste é o parâmetro.

A recompensa de verdade: qsort

O qsort da biblioteca padrão é o exemplo de ponteiro para função que você realmente vai usar. Ele ordena um array de qualquer coisa, e consegue isso sem saber nada sobre os elementos além do tamanho deles e de um comparador que você fornece.

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

O comparador recebe dois const void * - os endereços de dois elementos - e retorna um número negativo se o primeiro vem antes do segundo, zero se empatam, e positivo se vem depois.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // faz o cast de volta ao tipo real, depois le
    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);    // troca os argumentos para inverter a ordem
}

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("crescente:   ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

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

    return 0;
}

Dois hábitos para levar desse comparador. Nunca escreva return x - y; - parece esperto e transborda para valores grandes ou negativos, produzindo um sinal errado e um array mal ordenado. Faça o cast antes de desreferenciar, não depois: *(const int *)a, porque *a em um void * não tem nada para ler.

A mesma maquinaria ordena structs por qualquer campo que você quiser:

#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);   // maior primeiro
}

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 pontuacao:\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 nome:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

A expressão idiomática (q->score > p->score) - (q->score < p->score) retorna exatamente -1, 0 ou 1, sem subtração e sem overflow. E strcmp já tem a convenção de retorno certa, então um comparador de strings é uma linha só.

Tabelas de ponteiros para função

Um array de ponteiros para função transforma uma cadeia de if/else em uma consulta. É assim que interpretadores despacham opcodes e que sistemas de menu executam 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, "somar"},
        {'-', op_sub, "subtrair"},
        {'*', 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);
    }

    // despacha por um caractere, sem um 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;
}

Acrescentar uma operação agora é acrescentar uma linha, não editar um switch. Junte isso com structs e você tem o formato padrão de plugin em C: uma struct de ponteiros para função é o que significa "uma interface" nesta linguagem.

Coisas que mordem

As assinaturas precisam coincidir exatamente. O tipo de um ponteiro para função inclui os tipos dos parâmetros e o tipo de retorno. Atribuir uma função incompatível é uma violação de restrição, e chamar através de um ponteiro com o tipo errado é comportamento indefinido mesmo quando "funciona". Não faça cast da assinatura de um comparador para calar um aviso - conserte o comparador.

Um ponteiro para função nulo continua sendo um ponteiro nulo. Inicialize com NULL e verifique antes de chamar, exatamente como com ponteiros de dados:

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

Veja ponteiros nulos para entender por que essa verificação vale o esforço.

Ponteiros void perdem a segurança de tipos, e o sistema de tipos é você. Dentro de um comparador do qsort, nada impede que você faça cast para o tipo errado. Se você ordenar um array de double com compare_ints, isso compila limpo e produz besteira.

A sintaxe de declaradores aninha. Uma função que retorna um ponteiro para função é int (*get_op(char c))(int, int);. Quando você se pegar escrevendo isso, recorra ao typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // a mesma coisa, legível