Funções de callback

Muitas funções fazem quase a mesma coisa: percorrem um vetor, visitam os nós de uma árvore, ordenam elementos. O que muda de uma para outra é um detalhe, como o critério de seleção, a operação aplicada ou a forma de comparar. Nesta página, veremos como escrever a parte comum uma única vez e receber o detalhe que muda como parâmetro, na forma de uma função. Essa função passada como parâmetro é uma função de callback.

O problema: código duplicado

Suponha que queremos imprimir, de um vetor de inteiros, só os pares, só os ímpares, só os positivos e só os maiores que 10. A forma mais direta é escrever uma função para cada critério:

As quatro funções são idênticas, exceto pela condição do if e pelo título. Isso traz alguns problemas:

• Duplicação. O laço é sempre o mesmo, e só a condição muda.
• Pouca extensibilidade. Cada novo critério exige uma função inteira nova.
• Manutenção difícil. Uma mudança no laço (contar quantos elementos passaram, por exemplo) precisa ser repetida em todas as funções.
• Nenhum reúso. Cada função serve para um único critério.

O mesmo acontece com operações. Uma "calculadora" que mostra a conta antes do resultado teria uma função para cada operação, todas com o mesmo printf:

int calcularSoma(int a, int b) {
    printf("Calculando %d + %d = ", a, b);
    return a + b;
}

int calcularSubtracao(int a, int b) {
    printf("Calculando %d - %d = ", a, b);
    return a - b;
}

/* ... e o mesmo para multiplicação e divisão */

Nos dois casos, a parte que muda é um comportamento: um teste ou uma conta. Para escrever a parte comum uma só vez, precisamos passar esse comportamento como parâmetro.

A solução: funções de callback

Os dois termos descrevem a mesma ideia de ângulos diferentes. Função de alta ordem é o conceito: uma função que trata outras funções como dados, podendo recebê-las, guardá-las e devolvê-las. Callback é a função que é passada. Em C, isso é feito com ponteiros para função.

Com callbacks, o código comum (o laço, a impressão) é escrito uma única vez, e um novo comportamento exige só uma função pequena, sem tocar no que já existe.

Ponteiro para função

Em C, uma função também tem um endereço na memória: o endereço onde começa o seu código. Um ponteiro para função guarda esse endereço e permite chamar a função indiretamente. A declaração tem a forma

tipoRetorno (*nomePonteiro)(tipoParam1, tipoParam2, ...);

O nome de uma função, usado sem os parênteses de chamada, já é o seu endereço. Por isso ptr = somar e ptr = &somar são equivalentes. Do mesmo modo, a chamada pode ser escrita como ptr(5, 3) ou como (*ptr)(5, 3). Repare que o mesmo ponteiro chamou duas funções diferentes: quem decide qual função roda é o valor guardado em ptr, e não o código da chamada.

O ponteiro só pode guardar funções com a mesma assinatura (os mesmos tipos de parâmetros e de retorno). Alguns exemplos:

void (*notificar)(void);                     /* sem parâmetros, sem retorno */
int (*operacao)(int, int);                   /* dois int, devolve int */
void (*processar)(void *);                   /* um ponteiro genérico */
int (*comparar)(const void *, const void *); /* compara dois elementos */

int (*funcao)(int, int);   /* ponteiro para função que devolve int */
int *funcao(int, int);     /* função que devolve um ponteiro para int */

Simplificando com typedef

A sintaxe de ponteiros para função fica difícil de ler, principalmente quando o ponteiro é parâmetro de outra função. Um typedef dá um nome ao tipo:

/* Sem typedef */
void aplicar(int *v, int n, void (*processar)(int *));

/* Com typedef */
typedef void (*Processador)(int *);
void aplicar(int *v, int n, Processador processar);

No typedef, o nome novo (Processador) fica onde ficaria o nome do ponteiro. A partir daí, Processador é um tipo como outro qualquer: serve para declarar parâmetros, variáveis, campos de structs e vetores.

Resolvendo os exemplos com callback

Um único filtro

Em vez de quatro funções quase iguais, escrevemos uma função que recebe o critério como parâmetro. O critério é um predicado: uma função que recebe um elemento e diz se ele satisfaz uma condição.

imprimirFiltrado não sabe qual critério está usando. Ela só chama filtro(v[i]) e confia na resposta. O critério "negativos" foi acrescentado sem nenhuma mudança em imprimirFiltrado: bastou escrever ehNegativo.

Uma calculadora genérica

Na calculadora, o callback é a operação, e o símbolo vem junto para a mensagem:

A mensagem Calculando ... é escrita uma única vez, em calcular. Uma nova operação (o resto da divisão, por exemplo) é só mais uma função com a assinatura int (int, int).

Callbacks opcionais

Um ponteiro para função é um ponteiro, e pode valer NULL. Isso permite callbacks opcionais: quem chama passa uma função quando quer ser avisado de algo, e NULL quando não quer. A função que recebe o callback precisa então verificar o ponteiro antes de chamá-lo.

Callbacks com contexto

Os predicados de filtro.c têm um limite: ehMaiorQueDez só sabe comparar com 10. Para "maiores que 3", seria preciso outra função, e para "maiores que um valor lido do teclado", nenhuma função escrita de antemão resolve. O predicado precisa de um dado além do elemento.

A solução usual em C é acrescentar ao callback um parâmetro void *, o contexto. A função de alta ordem não sabe o que ele é: só o recebe de quem a chamou e o repassa, sem mexer, a cada chamada do callback. Quem escreve o callback sabe o tipo verdadeiro e faz a conversão.

O contexto pode ser um único valor (ehMaiorQue recebe um int *), uma struct com vários dados (estaEntre recebe os dois limites) e até um lugar onde o callback guarda resultados: ehMultiplo conta quantos elementos aceitou, e o main lê a contagem depois do filtro. Como o contexto é um void *, a mesma imprimirFiltrado serve para todos esses casos.

Esse par "ponteiro para função mais void *contexto" aparece em muitas bibliotecas de C. É assim que um percurso em uma árvore, por exemplo, pode somar valores, contar chaves ou copiá-las para um vetor sem que o código do percurso saiba de nada disso (veja o terceiro exercício desta página).

Funções que devolvem funções

Uma função de alta ordem também pode devolver uma função. Em despacho.c, operacaoPara recebe um símbolo e devolve a operação correspondente, ou NULL se o símbolo for desconhecido. O main lê expressões e usa a função devolvida sem precisar de um switch próprio.

Com o typedef, a declaração Operacao operacaoPara(char simbolo) é fácil de ler. Sem ele, ela seria int (*operacaoPara(char simbolo))(int, int): uma função que recebe um char e devolve um ponteiro para uma função que recebe dois int e devolve int. Esse é um bom motivo para sempre usar typedef com ponteiros para função.

A segunda parte do programa mostra outra forma de associar nomes a comportamentos: uma tabela de despacho, um vetor de structs em que cada entrada guarda um nome e a ação correspondente. Para acrescentar um comando, basta uma nova linha na tabela. É o mecanismo por trás de menus, de interpretadores de comandos e de sistemas de eventos, em que cada evento ("conectou", "recebeu dados", "erro") tem o seu callback.

Map, filter e reduce

Três funções de alta ordem clássicas, vindas da programação funcional, são map, filter e reduce. A imprimirFiltrado que escrevemos já é um filter especializado. Vamos generalizar:

O reduce começa com o valor inicial e, para cada elemento, faz resultado = acumular(resultado, v[i]). Para a soma de (1, 2, 3), com inicial 0, o cálculo é somar(somar(somar(0, 1), 2), 3).

A última linha do main mostra a principal vantagem dessas funções: elas se compõem. A saída de uma vira a entrada da próxima. Filtrando os pares de 1 a 10, dobrando e somando, obtemos .

Ordenação com vários comparadores

O exemplo mais conhecido de callback na biblioteca padrão é o qsort, visto na página de ponteiros void. O qsort sabe ordenar, mas não sabe comparar: quem diz se um elemento vem antes de outro é o comparador, um callback que recebe dois ponteiros e devolve um número negativo (o primeiro vem antes), zero (empate) ou positivo (o primeiro vem depois). Trocando o comparador, o mesmo qsort ordena em qualquer critério.

Alguns detalhes deste exemplo:

• Os parâmetros são const void *: o comparador só lê os elementos, e o const deixa isso explícito (é também a assinatura que o qsort exige).
• crescente devolve (x > y) - (x < y), que vale , ou . O atalho return x - y parece mais simples, mas pode estourar (com x = INT_MAX e y = -1, por exemplo) e devolver o sinal errado.
• decrescente reaproveita crescente, trocando a ordem dos argumentos.
• Para structs, cada critério é um comparador diferente. porNome usa strcmp, que já devolve negativo, zero ou positivo.

Outras aplicações

Callbacks aparecem sempre que uma função precisa de um comportamento que só quem a chama conhece:

A segunda linha da tabela é o assunto da próxima página, Estruturas Genéricas: combinando void * com callbacks, uma única implementação de uma estrutura de dados passa a servir para qualquer tipo de elemento.

Boas práticas e armadilhas

Use typedef. Um nome para o tipo do callback deixa as assinaturas legíveis, principalmente em funções que recebem ou devolvem callbacks.

Dê nomes descritivos. Predicado, Comparador e Acumulador dizem o que o callback faz. Nomes como Func ou CB não dizem nada.

Use const no que o callback só lê. Um comparador recebe const void *, e um callback de impressão também deveria receber.

Valide callbacks opcionais. Se NULL é um valor permitido, verifique antes de chamar. Se não é, documente isso.

Passe a função, não a chamada. filtrar(v, n, ehPar), e não filtrar(v, n, ehPar()).

Siga o contrato do callback. O comparador do qsort precisa devolver negativo, zero ou positivo, e não só verdadeiro ou falso. O valor inicial do reduce precisa ser o elemento neutro. Um callback que não cumpre o contrato pode produzir resultados errados sem nenhuma mensagem de erro (veja os exercícios a seguir).

Cuidado com o tempo de vida do contexto. O void *contexto precisa apontar para algo que ainda exista quando o callback for chamado.

Exercícios

Encontre e corrija o erro

Cada programa abaixo é uma versão de um exemplo desta página, com um erro. Execute, observe o que acontece e encontre a causa.

Programa 1

printf("Calculando %d %s %d = ", a, simbolo, b);

Programa 2

if (aoIniciar != NULL)
    aoIniciar();
printf("  [executando a tarefa...]\n");
if (aoFinalizar != NULL)
    aoFinalizar();

Programa 3

return (x > y) - (x < y);

Programa 4

printf("produto (10!): %lld\n", reduce(v, n, multiplicar, 1));

Programa 5

imprimirFiltrado(numeros, n, ehPar, "Pares");

Implemente

Predicados sobre vetores. Implemente as funções de predicados.h: contaSe (quantos elementos satisfazem o predicado), algum (algum satisfaz?), todos (todos satisfazem?) e primeiroQue (índice do primeiro que satisfaz, ou ). Além das respostas, os testes contam quantas vezes cada predicado é chamado: algum, todos e primeiroQue devem parar assim que a resposta estiver decidida.

Ordenação estável com comparador. Implemente ordena(v, n, cmp), que ordena um vetor de inteiros segundo o comparador cmp (negativo se a vem antes de b, positivo se vem depois, zero se tanto faz). A ordenação precisa ser estável: elementos empatados mantêm a ordem original. Os testes usam comparadores com muitos empates, como "pelo valor absoluto" e "pelo último dígito", e vetores com até 3000 elementos.

Percurso com callback na árvore de busca. O TAD da árvore binária de busca ganhou uma função de percurso:

typedef void (*Visita)(Chave chave, Valor valor, void *contexto);
void percorreEmOrdem(const Arvore *arvore, Visita visita, void *contexto);

Implemente percorreEmOrdem, que chama visita para cada par, em ordem crescente de chave, repassando o contexto sem alterá-lo. Depois, em usos.c, implemente somaValores, contaNoIntervalo e copiaChaves usando só percorreEmOrdem: o arquivo usos.c enxerga apenas a interface pública (Arvore.h) e não tem acesso aos nós. O último teste usa uma árvore com cerca de 50 mil chaves.

Referências

• A. Backes. Linguagem C: Completa e Descomplicada. 2ª ed. Elsevier, 2018.
• B. W. Kernighan e D. M. Ritchie. C: A Linguagem de Programação Padrão ANSI. Campus, 1989. Seção 5.11 (ponteiros para funções).
• qsort e bsearch. cppreference.com.