KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C

Callbacks in C: functiepointers met `typedef`

Geef een functiepointertype een naam om strategieën en predicaten door te geven, een gekozen functie terug te geven of callbacks in structs en arrays op te slaan.

Versie: ISO C23; implementation support may vary

Syntax

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); geeft de naam PricingFn aan het type pointer naar een functie die één double ontvangt en een double teruggeeft. Het is een alias, geen nieuw type of functie. De haakjes rond *PricingFn zijn belangrijk. typedef double PricingFunc(double); benoemt daarentegen het functietype; PricingFunc * komt overeen met PricingFn.

In PricingFn fn = add_fee; en bij het doorgeven als argument wordt de functienaam add_fee omgezet in een pointer; &add_fee kan ook. fn(base) en (*fn)(base) doen dezelfde indirecte aanroep. Een selectiefunctie kan een PricingFn teruggeven zonder de gekozen functie aan te roepen. Je kunt de pointer later vervangen in een variabele, of hem in een structveld opslaan en aanroepen met p->price(base).

PricingFn rules[] kan een array van functiepointers declareren; rules[i](base) roept de functie op index i aan. In een parameterdeclaratie wordt PricingFn rules[] aangepast tot PricingFn *: geef de lengte apart door en blijf binnen de arraygrenzen. Gebruik voor een dynamische array met n > 0 elementen PricingFn *items = malloc(n * sizeof *items); met <stdlib.h>, nadat je hebt gecontroleerd dat het product in size_t past. Handel NULL af, wijs aan elke gebruikte positie een geldige pointer toe en roep na gebruik free(items) aan. Je geeft daarmee de array vrij, niet de functies.

OrderPred ontvangt één const Order *: nul betekent onwaar, elke andere waarde betekent waar. Met een geldig predicaat roept count_if pred(&orders[i]) eenmaal per element aan. OrderCmp ontvangt twee const Order *-argumenten; een vergelijkingsfunctie geeft doorgaans een negatieve waarde, nul of een positieve waarde terug als het eerste element kleiner dan, gelijk aan of groter dan het tweede is.

Roep alleen aan via een geïnitialiseerde pointer die niet nul is en naar een functie met compatibele parameter- en retourtypen wijst. Aanroepen via NULL of via een pointer naar een incompatibel functietype heeft ongedefinieerd gedrag; een cast lost het verschil niet op. void * is geen draagbare vervanging voor een functiepointer. Deze constructies bestonden al vóór ISO C23; ondersteuning van de C23-modus verschilt per implementatie.

Voorbeelden

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

Resultaat

strategy: 12
switched: 20
matches: 2

`select_rule(0)` kiest `add_fee`. Vervolgens levert `rules[1]` de pointer naar `double_price`, die via een structveld wordt aangeroepen. `count_if` vindt twee passende bestellingen; in dit voorbeeld levert een ontbrekend predicaat (`NULL`) een telling van nul op.

Gerelateerde lessen

  • C · Les 39 · Gemiddeld · Versie: 3
  • C · Les 40 · Gemiddeld · Versie: 3
  • C · Les 41 · Gemiddeld · Versie: 3
  • C · Les 42 · Gemiddeld · Versie: 3
  • C · Les 43 · Gemiddeld · Versie: 3
  • C · Les 44 · Gemiddeld · Versie: 3
  • C · Les 45 · Gemiddeld · Versie: 3
  • C · Les 47 · Gemiddeld · Versie: 3
  • C · Les 48 · Gemiddeld · Versie: 3

Bronnen