CKTIS / C
Predicate : tableaux de prédicats en C
Définissez `Predicate` comme alias d’un type pointeur de fonction, puis utilisez un tableau de ces pointeurs pour vérifier si une commande satisfait toutes les règles ou au moins une.
Version : ISO C23; implementation support may vary
Syntaxe
typedef struct Order Order;
typedef int (*Predicate)(const Order *);
/* After declaring two functions with compatible types: */
const Predicate checks[] = {is_large, is_paid};Predicate est un alias de type défini par le programme, pas un nom standard du C. typedef int (*Predicate)(const Order *); désigne un pointeur vers une fonction qui prend un argument de type const Order * et renvoie un int. Les parenthèses autour de *Predicate font de l’alias un type pointeur. Par convention, 0 signifie faux et toute valeur non nulle signifie vrai. La fonction ne peut pas modifier la commande via ce pointeur, mais d’autres effets de bord restent possibles.
const Predicate checks[] = {is_large, is_paid}; crée un tableau dont les pointeurs de fonction ne peuvent pas être réaffectés. Les noms des fonctions dans l’initialisation sont convertis en pointeurs. checks[i](order) appelle la fonction d’indice i sur la même commande. Dans une liste de paramètres, const Predicate checks[] est ajusté en pointeur vers un élément : transmettez donc séparément le nombre n. Calculez sizeof checks / sizeof checks[0] là où checks est un tableau, pas dans la fonction auxiliaire.
all_match s’arrête au premier résultat nul et any_match au premier résultat non nul. Chaque fonction parcourt les règles dans l’ordre du tableau, ignore les suivantes dès que le résultat est connu et renvoie 0 ou 1. Si n == 0, aucun prédicat n’est appelé : all_match renvoie 1 et any_match renvoie 0. all_of et any_of ne sont pas des fonctions de la bibliothèque ISO C ; les fonctions auxiliaires sont définies dans l’exemple.
Pour n > 0, passez un tableau d’au moins n éléments, des pointeurs non nuls vers des fonctions de type compatible et un pointeur vers une commande dont la durée de vie couvre tout l’appel. Un appel via un pointeur nul ou un pointeur vers une fonction de type incompatible a un comportement indéfini. Cette technique existait avant C23 ; la prise en charge du mode C23 dépend de l’implémentation.
Exemples
#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;
}
Résultat
mixed: all=0 any=1 empty: all=1 any=0
Pour `{40, 2}`, `all_match` s’arrête quand `is_large` échoue. `any_match` poursuit avec `is_paid` et interprète `2` comme vrai. Les appels avec `NULL` et un nombre d’éléments égal à `0` ne lisent pas le tableau.
Leçons associées
- C · Leçon 56 · Intermédiaire · Version : 3