Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Predicate: array di predicati in C

Definisci `Predicate` come alias di un tipo puntatore a funzione e usa un array di questi puntatori per verificare se un ordine soddisfa tutte le regole o almeno una.

Versione: ISO C23; implementation support may vary

Sintassi

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

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

Predicate è un alias di tipo definito dal programma, non un nome standard del C. typedef int (*Predicate)(const Order *); indica un puntatore a una funzione che riceve un argomento di tipo const Order * e restituisce un int. Le parentesi attorno a *Predicate fanno sì che l’alias indichi un tipo puntatore. Per convenzione, 0 significa falso e ogni valore diverso da zero significa vero. La funzione non può modificare l’ordine tramite quel puntatore, ma può avere altri effetti collaterali.

const Predicate checks[] = {is_large, is_paid}; crea un array i cui puntatori a funzione non possono essere riassegnati. I nomi delle funzioni nell’inizializzatore vengono convertiti in puntatori. checks[i](order) chiama il predicato all’indice i sullo stesso ordine. Come parametro, const Predicate checks[] viene adattato a un puntatore a un elemento: passa quindi il numero n separatamente. Calcola sizeof checks / sizeof checks[0] dove checks è un array, non dentro la funzione ausiliaria.

all_match si ferma al primo risultato zero; any_match al primo risultato diverso da zero. Entrambe esaminano le regole nell’ordine dell’array, saltano le rimanenti non appena conoscono l’esito e restituiscono 0 o 1. Se n == 0, non viene chiamato alcun predicato: all_match restituisce 1 e any_match restituisce 0. all_of e any_of non sono funzioni della libreria ISO C; l’esempio definisce le proprie funzioni ausiliarie.

Per n > 0, passa un array con almeno n elementi, puntatori non nulli a funzioni di tipo compatibile e un puntatore a un ordine che rimanga valido per tutta la chiamata. Una chiamata tramite un puntatore nullo o un puntatore a una funzione di tipo incompatibile ha comportamento indefinito. Questa tecnica precede C23; il supporto della modalità C23 dipende dall’implementazione.

Esempi

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

Risultato

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

Con `{40, 2}`, `all_match` si ferma quando `is_large` restituisce zero. `any_match` prosegue con `is_paid` e interpreta `2` come vero. Le chiamate con `NULL` e un numero di elementi pari a `0` non leggono l’array.

Lezioni correlate

  • C · Lezione 56 · Intermedio · Versione: 3

Fonti