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

CKTIS / C

Predicate: arrays de predicados em C

Define `Predicate` como um alias para um tipo de ponteiro para função e usa um array desses ponteiros para verificar se uma encomenda cumpre todas as regras ou pelo menos uma.

Versão: ISO C23; implementation support may vary

Sintaxe

typedef struct Order Order;
typedef int (*Predicate)(const Order *);

/* After declaring two functions with compatible types: */
const Predicate checks[] = {is_large, is_paid};

Predicate é um alias de tipo definido pelo programa, não um nome da norma C. typedef int (*Predicate)(const Order *); designa um ponteiro para uma função que recebe um argumento do tipo const Order * e devolve um int. Os parênteses à volta de *Predicate fazem com que o alias designe um tipo de ponteiro. Por convenção, 0 significa falso e qualquer valor diferente de zero significa verdadeiro. A função não pode alterar a encomenda através desse ponteiro, mas pode ter outros efeitos secundários.

const Predicate checks[] = {is_large, is_paid}; cria um array cujos ponteiros para funções não podem ser reatribuídos. Os nomes das funções no inicializador são convertidos em ponteiros. checks[i](order) chama o predicado no índice i para a mesma encomenda. Como parâmetro, const Predicate checks[] é ajustado para um ponteiro para um elemento, pelo que se passa o número n em separado. Calcula sizeof checks / sizeof checks[0] onde checks é um array, não dentro da função auxiliar.

all_match termina no primeiro resultado igual a zero e any_match no primeiro resultado diferente de zero. Ambas percorrem as regras pela ordem do array, ignoram as restantes logo que sabem a resposta e devolvem 0 ou 1. Se n == 0, não é chamado nenhum predicado: all_match devolve 1 e any_match devolve 0. all_of e any_of não são funções da biblioteca do C ISO; o exemplo define as suas próprias funções auxiliares.

Para n > 0, passa um array com pelo menos n elementos, ponteiros não nulos para funções de tipo compatível e um ponteiro para uma encomenda que permaneça válida durante toda a chamada. Uma chamada através de um ponteiro nulo ou de um ponteiro para uma função de tipo incompatível tem comportamento indefinido. Esta técnica é anterior a C23; o suporte do modo C23 depende da implementação.

Exemplos

#include <stddef.h>
#include <stdio.h>

typedef struct Order {
    int total;
    int paid;
} Order;

typedef int (*Predicate)(const Order *);

static int is_large(const Order *order)
{
    return order->total >= 100;
}

static int is_paid(const Order *order)
{
    return order->paid;
}

static int all_match(const Predicate checks[], size_t n, const Order *order)
{
    for (size_t i = 0; i < n; ++i) {
        if (!checks[i](order)) {
            return 0;
        }
    }
    return 1;
}

static int any_match(const Predicate checks[], size_t n, const Order *order)
{
    for (size_t i = 0; i < n; ++i) {
        if (checks[i](order)) {
            return 1;
        }
    }
    return 0;
}

int main(void)
{
    const Order order = {40, 2};
    const Predicate checks[] = {is_large, is_paid};
    const size_t n = sizeof checks / sizeof checks[0];

    const int all = all_match(checks, n, &order);
    const int any = any_match(checks, n, &order);
    printf("mixed: all=%d any=%d\n", all, any);
    printf("empty: all=%d any=%d\n",
           all_match(NULL, 0, &order), any_match(NULL, 0, &order));
    return 0;
}

Resultado

mixed: all=0 any=1
empty: all=1 any=0

Com `{40, 2}`, `all_match` termina quando `is_large` falha. `any_match` prossegue com `is_paid`, cujo resultado `2` conta como verdadeiro. As chamadas com `NULL` e um número de elementos igual a `0` não leem o array.

Lições relacionadas

  • C · Lição 56 · Intermédio · Versão: 3

Fontes