WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C

Callbacks in C: Funktionszeiger mit `typedef`

Benenne einen Funktionszeigertyp, um Strategien und Prädikate zu übergeben, eine gewählte Funktion zurückzugeben oder Callbacks in Strukturen und Arrays zu speichern.

Version: 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); gibt dem Zeigertyp auf eine Funktion, die einen double entgegennimmt und einen double zurückgibt, den Namen PricingFn. Das ist ein Alias, kein neuer Typ und keine Funktion. Die Klammern um *PricingFn sind wichtig. Dagegen benennt typedef double PricingFunc(double); den Funktionstyp; PricingFunc * entspricht PricingFn.

In PricingFn fn = add_fee; und bei der Übergabe als Argument wird der Funktionsname add_fee in einen Zeiger umgewandelt; &add_fee geht ebenfalls. fn(base) und (*fn)(base) bewirken denselben indirekten Aufruf. Eine Auswahlfunktion kann PricingFn zurückgeben, ohne die gewählte Funktion aufzurufen. Danach kannst du den Zeiger in einer Variablen austauschen oder ihn in einem Strukturfeld speichern und per p->price(base) aufrufen.

PricingFn rules[] kann ein Array von Funktionszeigern deklarieren; rules[i](base) ruft die Funktion am Index i auf. Als Parameter wird PricingFn rules[] zu PricingFn * angepasst: Übergib die Länge separat und halte die Arraygrenzen ein. Für ein dynamisches Array mit n > 0 Elementen verwende PricingFn *items = malloc(n * sizeof *items); aus <stdlib.h>, nachdem du geprüft hast, ob das Produkt in size_t darstellbar ist. Behandle NULL, weise jedem benutzten Element einen gültigen Zeiger zu und rufe am Ende free(items) auf. Das gibt das Array frei, nicht die Funktionen.

OrderPred nimmt einen const Order * entgegen: Null bedeutet falsch, jeder andere Wert wahr. Bei gültigem Prädikat ruft count_if für jedes Element einmal pred(&orders[i]) auf. OrderCmp nimmt zwei const Order * entgegen; ein üblicher Vergleich liefert einen negativen Wert, Null oder einen positiven Wert, wenn das erste Element kleiner, gleich bzw. größer als das zweite ist.

Rufe nur über einen initialisierten Zeiger auf, der nicht null ist und auf eine Funktion mit kompatiblen Parameter- und Rückgabetypen zeigt. Ein Aufruf über NULL oder einen Zeiger auf einen inkompatiblen Funktionstyp hat undefiniertes Verhalten; ein Cast behebt die Inkompatibilität nicht. void * ist kein portabler Ersatz für einen Funktionszeiger. Diese Konstrukte gab es vor ISO C23; die Unterstützung des C23-Modus ist implementationsabhängig.

Beispiele

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

Ergebnis

strategy: 12
switched: 20
matches: 2

`select_rule(0)` wählt `add_fee`. Danach liefert `rules[1]` den Zeiger auf `double_price`; der Aufruf erfolgt über ein Strukturfeld. `count_if` findet zwei passende Bestellungen; bei fehlendem Prädikat (`NULL`) liefert es in diesem Beispiel null.

Zugehörige Lektionen

  • C · Lektion 39 · Mittlere Stufe · Version: 3
  • C · Lektion 40 · Mittlere Stufe · Version: 3
  • C · Lektion 41 · Mittlere Stufe · Version: 3
  • C · Lektion 42 · Mittlere Stufe · Version: 3
  • C · Lektion 43 · Mittlere Stufe · Version: 3
  • C · Lektion 44 · Mittlere Stufe · Version: 3
  • C · Lektion 45 · Mittlere Stufe · Version: 3
  • C · Lektion 47 · Mittlere Stufe · Version: 3
  • C · Lektion 48 · Mittlere Stufe · Version: 3

Quellen