Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C

Callbacky v C: ukazatele na funkce pomocí `typedef`

Pojmenujte typ ukazatele na funkci a používejte jej k předávání strategií a predikátů, vracení vybrané funkce nebo ukládání callbacků do struktur a polí.

Verze: ISO C23; implementation support may vary

Syntaxe

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ádí jméno PricingFn pro typ ukazatele na funkci, která přijímá jeden double a vrací double. Jde o alias, nikoli o nový typ ani funkci. Závorky kolem *PricingFn jsou důležité. Naproti tomu typedef double PricingFunc(double); pojmenovává typ funkce; PricingFunc * je totéž co PricingFn.

V PricingFn fn = add_fee; i při předání argumentu se jméno funkce add_fee převede na ukazatel; lze použít také &add_fee. fn(base) a (*fn)(base) provádějí stejné nepřímé volání. Výběrová funkce může vrátit PricingFn, aniž by vybranou funkci zavolala. Ukazatel pak můžete v proměnné nahradit nebo ho uložit do členu struktury a volat pomocí p->price(base).

PricingFn rules[] může deklarovat pole ukazatelů na funkce; rules[i](base) zavolá funkci na indexu i. V deklaraci parametru se PricingFn rules[] upraví na PricingFn *: délku předejte zvlášť a dodržujte meze pole. Pro dynamické pole s n > 0 prvky použijte PricingFn *items = malloc(n * sizeof *items); s <stdlib.h> až po ověření, že se součin vejde do size_t. Ošetřete NULL, přiřaďte platný ukazatel do každé používané položky a nakonec zavolejte free(items). Uvolníte tím pole, nikoli funkce.

OrderPred přijímá jeden const Order *: nula znamená nepravdu a nenulová hodnota pravdu. S platným predikátem volá count_if výraz pred(&orders[i]) jednou pro každý prvek. OrderCmp přijímá dva argumenty typu const Order *; běžný komparátor vrací zápornou hodnotu, nulu nebo kladnou hodnotu podle toho, zda je první prvek menší, roven nebo větší než druhý.

Volejte jen přes inicializovaný nenulový ukazatel na funkci s kompatibilními typy parametrů a výsledku. Volání přes NULL nebo přes ukazatel na nekompatibilní typ funkce má nedefinované chování; přetypování nesoulad neodstraní. void * není přenositelnou náhradou za ukazatel na funkci. Tyto konstrukce existovaly už před ISO C23; podpora režimu C23 závisí na implementaci.

Pří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ýsledek

strategy: 12
switched: 20
matches: 2

`select_rule(0)` vybere `add_fee`. Potom `rules[1]` poskytne `double_price`, která se zavolá přes člen struktury. `count_if` najde dvě vyhovující objednávky; v tomto příkladu vrátí při chybějícím predikátu (`NULL`) nulu.

Související lekce

  • C · Lekce 39 · Středně pokročilá · Verze: 3
  • C · Lekce 40 · Středně pokročilá · Verze: 3
  • C · Lekce 41 · Středně pokročilá · Verze: 3
  • C · Lekce 42 · Středně pokročilá · Verze: 3
  • C · Lekce 43 · Středně pokročilá · Verze: 3
  • C · Lekce 44 · Středně pokročilá · Verze: 3
  • C · Lekce 45 · Středně pokročilá · Verze: 3
  • C · Lekce 47 · Středně pokročilá · Verze: 3
  • C · Lekce 48 · Středně pokročilá · Verze: 3

Zdroje