CKTIS / C
Fonctions de rappel en C : pointeurs de fonction avec `typedef`
Nommez un type de pointeur de fonction pour passer des stratégies et des prédicats, renvoyer une fonction choisie ou conserver des rappels dans des structures et des tableaux.
Version : ISO C23; implementation support may vary
Syntaxe
typedef double (*PricingFn)(double);
typedef double PricingFunc(double); /* PricingFunc * is equivalent to PricingFn */
typedef struct Order Order;
typedef int (*OrderPred)(const Order *);
typedef int (*OrderCmp)(const Order *, const Order *);
double add_fee(double);
double double_price(double);
double apply_price(double base, PricingFn fn);
PricingFn select_rule(int use_double);
void apply_rules(PricingFn rules[], size_t n); /* include <stddef.h> for size_t */
typedef struct {
PricingFn price;
} InvoiceProcessor;
/* Inside a function, with add_fee and double_price declared: */
PricingFn fn = add_fee;
PricingFn rules[] = {add_fee, &double_price};
InvoiceProcessor processor = {fn};typedef double (*PricingFn)(double); nomme PricingFn le type pointeur vers une fonction qui prend un double et renvoie un double. C’est un alias, pas un nouveau type ni une fonction. Les parenthèses autour de *PricingFn sont importantes. En revanche, typedef double PricingFunc(double); nomme le type de fonction ; PricingFunc * équivaut à PricingFn.
Dans PricingFn fn = add_fee; et lors du passage en argument, le nom de fonction add_fee est converti en pointeur ; &add_fee convient aussi. fn(base) et (*fn)(base) produisent le même appel indirect. Une fonction de sélection peut renvoyer un PricingFn sans appeler la fonction choisie. On peut ensuite remplacer le pointeur dans une variable ou le stocker dans un champ de structure et appeler p->price(base).
PricingFn rules[] peut déclarer un tableau de pointeurs de fonction ; rules[i](base) appelle la fonction à l’indice i. Dans une déclaration de paramètre, PricingFn rules[] est ajusté en PricingFn * : passez la longueur séparément et respectez les bornes. Pour un tableau dynamique de n > 0 éléments, utilisez PricingFn *items = malloc(n * sizeof *items); avec <stdlib.h> après avoir vérifié que le produit tient dans size_t. Gérez NULL, affectez un pointeur valide à chaque case utilisée et terminez par free(items). Cela libère le tableau, pas les fonctions.
OrderPred prend un const Order * : zéro signifie faux, toute autre valeur signifie vrai. Avec un prédicat valide, count_if appelle pred(&orders[i]) une fois par élément. OrderCmp prend deux const Order * ; un comparateur renvoie typiquement une valeur négative, zéro ou une valeur positive selon que le premier élément est inférieur, égal ou supérieur au second.
N’appelez qu’au moyen d’un pointeur initialisé et non nul vers une fonction dont les types des paramètres et du résultat sont compatibles. Un appel via NULL ou via un pointeur vers un type de fonction incompatible a un comportement indéfini ; une conversion explicite ne règle pas l’incompatibilité. void * n’est pas un substitut portable à un pointeur de fonction. Ces constructions sont antérieures à ISO C23 ; la prise en charge du mode C23 varie selon l’implémentation.
Exemples
#include <stdio.h>
typedef double (*PricingFn)(double);
typedef struct {
int total;
} Order;
typedef int (*OrderPred)(const Order *);
typedef struct {
PricingFn price;
} InvoiceProcessor;
static double add_fee(double base) { return base + 2.0; }
static double double_price(double base) { return base * 2.0; }
static int is_large(const Order *order) { return order->total >= 10; }
static double apply_price(double base, PricingFn fn)
{
return fn(base); /* Caller must supply a valid callback. */
}
static PricingFn select_rule(int use_double)
{
return use_double ? double_price : add_fee;
}
static size_t count_if(const Order orders[], size_t n, OrderPred pred)
{
size_t matches = 0;
if (pred == NULL)
return 0;
for (size_t i = 0; i < n; ++i)
if (pred(&orders[i]))
++matches;
return matches;
}
int main(void)
{
PricingFn fn = select_rule(0);
printf("strategy: %.0f\n", apply_price(10.0, fn));
PricingFn rules[] = {add_fee, &double_price};
fn = rules[1];
InvoiceProcessor processor = {fn};
const InvoiceProcessor *p = &processor;
printf("switched: %.0f\n", p->price(10.0));
const Order orders[] = {{7}, {10}, {24}};
printf("matches: %zu\n",
count_if(orders, sizeof orders / sizeof orders[0], is_large));
return 0;
}
Résultat
strategy: 12 switched: 20 matches: 2
`select_rule(0)` choisit `add_fee`. Puis `rules[1]` fournit `double_price`, appelée via un champ de structure. `count_if` trouve deux commandes correspondantes ; dans cet exemple, un prédicat absent (`NULL`) donne un résultat de zéro.
Leçons associées
- C · Leçon 39 · Intermédiaire · Version : 3
- C · Leçon 40 · Intermédiaire · Version : 3
- C · Leçon 41 · Intermédiaire · Version : 3
- C · Leçon 42 · Intermédiaire · Version : 3
- C · Leçon 43 · Intermédiaire · Version : 3
- C · Leçon 44 · Intermédiaire · Version : 3
- C · Leçon 45 · Intermédiaire · Version : 3
- C · Leçon 47 · Intermédiaire · Version : 3
- C · Leçon 48 · Intermédiaire · Version : 3