Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C

Povratne funkcije v C: kazalci na funkcije s `typedef`

Poimenuj tip kazalca na funkcijo, da lahko podaš strategijo ali predikat, vrneš izbrano funkcijo ali shraniš povratne funkcije v strukture in polja.

Različica: 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); uvede ime PricingFn za tip kazalca na funkcijo, ki sprejme en double in vrne double. To je drugo ime za isti tip, ne nov tip ali funkcija. Oklepaji okoli *PricingFn so pomembni. Nasprotno pa typedef double PricingFunc(double); poimenuje tip funkcije; PricingFunc * je enakovreden PricingFn.

V PricingFn fn = add_fee; in pri podajanju argumenta se ime funkcije add_fee pretvori v kazalec; deluje tudi &add_fee. fn(base) in (*fn)(base) izvedeta isti posredni klic. Izbirna funkcija lahko vrne PricingFn, ne da bi poklicala izbrano funkcijo. Kazalec lahko pozneje zamenjaš v spremenljivki ali ga shraniš v članu strukture in funkcijo pokličeš z p->price(base).

PricingFn rules[] lahko deklarira polje kazalcev na funkcije; rules[i](base) pokliče funkcijo z indeksom i. V deklaraciji parametra se PricingFn rules[] prilagodi v PricingFn *: dolžino podaj posebej in upoštevaj meje polja. Za dinamično polje z n > 0 elementi uporabi PricingFn *items = malloc(n * sizeof *items); z <stdlib.h>, potem ko preveriš, da je produkt predstavljiv v size_t. Obravnavaj NULL, vsaki uporabljeni mesti v polju priredi veljaven kazalec in na koncu pokliči free(items). S tem sprostiš polje, ne funkcij.

OrderPred sprejme en const Order *: nič pomeni neresnično, vrednost, različna od nič, pa resnično. Pri veljavnem predikatu count_if pokliče pred(&orders[i]) enkrat na element. OrderCmp sprejme dva argumenta tipa const Order *; primerjalna funkcija običajno vrne negativno vrednost, nič ali pozitivno vrednost, če je prvi element manjši od drugega, enak drugemu ali večji od drugega.

Kliči samo prek inicializiranega kazalca, ki ni ničeln in kaže na funkcijo z združljivimi tipi parametrov in rezultata. Klic prek NULL ali kazalca na nezdružljiv tip funkcije ima nedefinirano obnašanje; eksplicitna pretvorba tipa ne odpravi nezdružljivosti. void * ni prenosljiva zamenjava za kazalec na funkcijo. Ti konstrukti so obstajali že pred ISO C23; podpora za način C23 je odvisna od implementacije.

Primeri

#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)` izbere `add_fee`. Nato `rules[1]` poda `double_price`, ki se pokliče prek člana strukture. `count_if` najde dve ustrezni naročili; v tem primeru ob manjkajočem predikatu (`NULL`) vrne nič.

Povezane lekcije

  • C · Lekcija 39 · Srednja · Različica: 3
  • C · Lekcija 40 · Srednja · Različica: 3
  • C · Lekcija 41 · Srednja · Različica: 3
  • C · Lekcija 42 · Srednja · Različica: 3
  • C · Lekcija 43 · Srednja · Različica: 3
  • C · Lekcija 44 · Srednja · Različica: 3
  • C · Lekcija 45 · Srednja · Različica: 3
  • C · Lekcija 47 · Srednja · Različica: 3
  • C · Lekcija 48 · Srednja · Različica: 3

Viri