Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C

Callbacki w C: wskaźniki do funkcji z `typedef`

Nadaj typowi wskaźnika do funkcji krótką nazwę i używaj go do przekazywania strategii i predykatów, zwracania wybranej funkcji oraz przechowywania callbacków w strukturach i tablicach.

Wersja: ISO C23; implementation support may vary

Składnia

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); nadaje nazwę PricingFn typowi wskaźnika do funkcji, która przyjmuje jeden double i zwraca double. Powstaje alias, a nie nowy typ ani funkcja. Nawiasy wokół *PricingFn są istotne. Dla porównania typedef double PricingFunc(double); nazywa typ funkcji; dopiero PricingFunc * oznacza ten sam typ co PricingFn.

W inicjalizacji PricingFn fn = add_fee; i przy przekazywaniu argumentu nazwa add_fee jest automatycznie przekształcana na wskaźnik; można też napisać &add_fee. Wywołania fn(base) i (*fn)(base) są równoważne. Selektor może zwrócić PricingFn bez wywoływania wybranej funkcji. Wskaźnik można później podmienić w zmiennej lub zapisać w polu struktury i wywołać przez p->price(base).

PricingFn rules[] może być tablicą wskaźników; rules[i](base) wywołuje funkcję z pozycji i. W deklaracji parametru zapis PricingFn rules[] jest dostosowywany do PricingFn *: przekaż długość osobno i pilnuj granic. Dla dynamicznej tablicy o n > 0 elementach użyj PricingFn *items = malloc(n * sizeof *items); z <stdlib.h> po sprawdzeniu, czy iloczyn mieści się w size_t. Obsłuż NULL, zapisz poprawny wskaźnik w każdej używanej pozycji i na końcu wywołaj free(items). Zwalniasz tablicę, nie funkcje.

OrderPred przyjmuje const Order *: zero oznacza fałsz, a wartość niezerowa prawdę. Dla poprawnego predykatu count_if wywołuje pred(&orders[i]) raz na element. OrderCmp przyjmuje dwa const Order *; typowa umowa komparatora przewiduje wynik ujemny, zero lub wynik dodatni, gdy pierwszy element jest odpowiednio mniejszy, równy lub większy od drugiego.

Wywołuj tylko zainicjalizowany, niepusty wskaźnik do funkcji o zgodnym typie parametrów i wyniku. Wywołanie przez NULL lub przez wskaźnik do niezgodnego typu funkcji ma niezdefiniowane zachowanie; rzutowanie nie naprawia niezgodności. void * nie jest przenośnym zamiennikiem wskaźnika do funkcji. Te konstrukcje nie są nowością w ISO C23; obsługa trybu C23 zależy od implementacji.

Przykłady

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

Wynik

strategy: 12
switched: 20
matches: 2

`select_rule(0)` wybiera `add_fee`. Następnie `rules[1]` dostarcza `double_price`, wywoływaną przez pole struktury. `count_if` znajduje dwa pasujące zamówienia; w tym przykładzie brak predykatu (`NULL`) daje wynik zero.

Powiązane lekcje

  • C · Lekcja 39 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 40 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 41 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 42 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 43 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 44 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 45 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 47 · Średniozaawansowany · Wersja: 3
  • C · Lekcja 48 · Średniozaawansowany · Wersja: 3

Źródła