Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C

Declaradores de ponteiros para funções e comparadores como callbacks em C

Declare um tipo de ponteiro para função, passe um comparador compatível e compare prioridades sem transbordo, mesmo nos limites do tipo `int`.

Versão: ISO C23; implementation support may vary

Sintaxe

/* 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 *); dá o nome ProcessCmp ao tipo do ponteiro, não ao da função. A função recebe dois ponteiros para const Process e devolve um int. Os parênteses em torno de *ProcessCmp são essenciais: int (*f)(...) declara um ponteiro para uma função que devolve int, enquanto int *f(...) declara uma função que devolve int *. Aqui, ... representa uma lista de parâmetros omitida.

apply_cmp recebe um parâmetro ProcessCmp cmp. Ao passar by_priority, o designador da função é convertido implicitamente num ponteiro; também se pode usar &by_priority. Em apply_cmp, cmp(a, b) e (*cmp)(a, b) são equivalentes. Passe um ponteiro não nulo para uma função de tipo compatível e ponteiros para objetos Process que se mantenham vivos durante toda a chamada. Uma conversão explícita não torna válida uma chamada através de um tipo de função incompatível: o comportamento é indefinido.

O contrato do comparador baseia-se no sinal do resultado: negativo se a primeira chave for menor, zero se as chaves forem iguais e positivo se a primeira for maior. INT_MIN e INT_MAX, definidos em <limits.h>, são os valores mínimo e máximo de int. Comparar através de x - y pode provocar transbordo de um int com sinal, o que dá origem a comportamento indefinido. Em vez disso, (x > y) - (x < y) subtrai apenas resultados de comparações do tipo int com valor 0 ou 1, produzindo -1, 0 ou 1 mesmo nos extremos.

O menos unário em -r inverte o sinal. É seguro para um resultado normalizado para -1, 0 ou 1, mas um comparador arbitrário pode devolver INT_MIN, cuja negação tem comportamento indefinido em C23. Para inverter a ordem sem negar o resultado, troque os argumentos: cmp(b, a). A sintaxe é válida em ISO C23; o suporte de C23 pode variar consoante a implementação.

Exemplos

#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

A primeira linha mostra, por ordem, uma prioridade menor, igual e maior. A segunda mostra o resultado da comparação «menor do que» com o sinal invertido. As prioridades iguais pertencem a dois objetos distintos.

Lições relacionadas

  • C · Lição 76 · Avançado · Versão: 3

Fontes