Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C

Callbacky v C: ukazovatele na funkcie pomocou `typedef`

Pomenujte typ ukazovateľa na funkciu a používajte ho na odovzdávanie stratégií a predikátov, vrátenie vybranej funkcie alebo uloženie callbackov do štruktúr a polí.

Verzia: 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); zavádza názov PricingFn pre typ ukazovateľa na funkciu, ktorá prijíma jeden double a vracia double. Je to alias, nie nový typ ani funkcia. Zátvorky okolo *PricingFn sú dôležité. Naproti tomu typedef double PricingFunc(double); pomenúva typ funkcie; PricingFunc * je ekvivalentný s PricingFn.

V PricingFn fn = add_fee; aj pri odovzdávaní argumentu sa názov funkcie add_fee konvertuje na ukazovateľ; použiť sa dá aj &add_fee. fn(base) a (*fn)(base) vykonajú rovnaké nepriame volanie. Výberová funkcia môže vrátiť PricingFn bez volania vybranej funkcie. Ukazovateľ môžete neskôr v premennej nahradiť alebo ho uložiť do člena štruktúry a volať cez p->price(base).

PricingFn rules[] môže deklarovať pole ukazovateľov na funkcie; rules[i](base) zavolá funkciu na indexe i. V deklarácii parametra sa PricingFn rules[] upraví na PricingFn *: dĺžku odovzdajte samostatne a dodržujte hranice poľa. Pre dynamické pole s n > 0 prvkami použite PricingFn *items = malloc(n * sizeof *items); s <stdlib.h> po overení, že sa súčin zmestí do size_t. Ošetrite NULL, do každej používanej položky priraďte platný ukazovateľ a nakoniec zavolajte free(items). Uvoľní sa pole, nie funkcie.

OrderPred prijíma jeden const Order *: nula znamená nepravdu a nenulová hodnota pravdu. S platným predikátom count_if zavolá pred(&orders[i]) raz pre každý prvok. OrderCmp prijíma dva argumenty typu const Order *; bežný komparátor vracia zápornú hodnotu, nulu alebo kladnú hodnotu podľa toho, či je prvý prvok menší než druhý, rovný druhému alebo väčší než druhý.

Volajte len cez inicializovaný nenulový ukazovateľ na funkciu s kompatibilnými typmi parametrov a návratovej hodnoty. Volanie cez NULL alebo cez ukazovateľ na nekompatibilný typ funkcie má nedefinované správanie; pretypovanie nezlučiteľnosť neodstráni. void * nie je prenosnou náhradou za ukazovateľ na funkciu. Tieto konštrukcie existovali už pred ISO C23; podpora režimu C23 závisí od implementácie.

Príklady

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

Výsledok

strategy: 12
switched: 20
matches: 2

`select_rule(0)` vyberie `add_fee`. Potom `rules[1]` poskytne `double_price`, ktorá sa zavolá cez člena štruktúry. `count_if` nájde dve vyhovujúce objednávky; v tomto príklade pri chýbajúcom predikáte (`NULL`) vráti nulu.

Súvisiace lekcie

  • C · Lekcia 39 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 40 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 41 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 42 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 43 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 44 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 45 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 47 · Stredne pokročilá · Verzia: 3
  • C · Lekcia 48 · Stredne pokročilá · Verzia: 3

Zdroje