CKTIS / C
Povratne funkcije u C-u: pokazivači na funkcije s `typedef`
Imenuj tip pokazivača na funkciju kako bi mogao proslijediti strategiju ili predikat, vratiti odabranu funkciju ili pohraniti povratne funkcije u strukture i polja.
Verzija: ISO C23; implementation support may vary
Sintaksa
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); uvodi ime PricingFn za tip pokazivača na funkciju koja prima jedan double i vraća double. To je drugo ime za isti tip, a ne novi tip ili funkcija. Zagrade oko *PricingFn važne su. Nasuprot tome, typedef double PricingFunc(double); imenuje tip funkcije; PricingFunc * odgovara tipu PricingFn.
U PricingFn fn = add_fee; i pri prosljeđivanju argumenta ime funkcije add_fee pretvara se u pokazivač; možeš napisati i &add_fee. fn(base) i (*fn)(base) izvršavaju isti neizravni poziv. Funkcija za odabir može vratiti PricingFn bez pozivanja odabrane funkcije. Poslije možeš zamijeniti pokazivač u varijabli ili ga pohraniti u član strukture i pozvati funkciju izrazom p->price(base).
PricingFn rules[] može deklarirati polje pokazivača na funkcije; rules[i](base) poziva funkciju na indeksu i. U deklaraciji parametra PricingFn rules[] prilagođava se u PricingFn *: duljinu proslijedi zasebno i poštuj granice polja. Za dinamičko polje s n > 0 elemenata upotrijebi PricingFn *items = malloc(n * sizeof *items); uz <stdlib.h> nakon što provjeriš može li se umnožak prikazati tipom size_t. Obradi NULL, svakom elementu koji koristiš dodijeli valjan pokazivač i na kraju pozovi free(items). Time oslobađaš polje, a ne funkcije.
OrderPred prima jedan const Order *: nula znači neistinu, a vrijednost različita od nule istinu. Uz valjan predikat count_if poziva pred(&orders[i]) jednom za svaki element. OrderCmp prima dva argumenta tipa const Order *; funkcija za usporedbu obično vraća negativnu vrijednost, nulu ili pozitivnu vrijednost ako je prvi element manji od drugog, jednak drugom ili veći od drugog.
Pozivaj samo preko inicijaliziranog pokazivača koji nije nul-pokazivač i koji pokazuje na funkciju s kompatibilnim tipovima parametara i povratne vrijednosti. Poziv preko NULL ili preko pokazivača na nekompatibilan tip funkcije ima nedefinirano ponašanje; eksplicitna pretvorba tipa ne uklanja nekompatibilnost. void * nije prenosiva zamjena za pokazivač na funkciju. Ove konstrukcije postoje od prije norme ISO C23; podrška za način rada C23 ovisi o implementaciji.
Primjeri
#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;
}
Rezultat
strategy: 12 switched: 20 matches: 2
`select_rule(0)` odabire `add_fee`. Zatim `rules[1]` daje `double_price`, koja se poziva preko člana strukture. `count_if` pronalazi dvije odgovarajuće narudžbe; u ovom primjeru, ako predikat nedostaje (`NULL`), rezultat je nula.
Povezane lekcije
- C · Lekcija 39 · Srednje · Verzija: 3
- C · Lekcija 40 · Srednje · Verzija: 3
- C · Lekcija 41 · Srednje · Verzija: 3
- C · Lekcija 42 · Srednje · Verzija: 3
- C · Lekcija 43 · Srednje · Verzija: 3
- C · Lekcija 44 · Srednje · Verzija: 3
- C · Lekcija 45 · Srednje · Verzija: 3
- C · Lekcija 47 · Srednje · Verzija: 3
- C · Lekcija 48 · Srednje · Verzija: 3