Wskaźniki na funkcje w C: składnia, callbacki i qsort

Skompilowany kod leży w pamięci tak samo jak dane, więc funkcja ma adres. Wskaźnik na funkcję to zmienna, która przechowuje taki adres. A skoro można przechować funkcję, można ją też przekazać jako argument, trzymać ich tablicę albo wybierać między nimi w czasie działania programu.

Na tym opiera się sortowanie według własnej kolejności, obsługa zdarzeń, interfejsy wtyczek i maszyny stanów. To też fragment składni C, przy którym czytelnik najczęściej się zatrzymuje i mruży oczy, więc od niego zaczniemy.

Składnia deklaracji

Weź zwykłą funkcję:

int add(int a, int b);

Żeby zadeklarować wskaźnik, który może przechować jej adres, zastąp nazwę przez (*nazwa):

int (*op)(int, int);

Czytaj od środka: op to wskaźnik, na funkcję, która przyjmuje (int, int) i zwraca int.

Nawiasy nie są ozdobą. Bez nich * wiąże się z typem zwracanym:

int (*f)(int);   // wskaźnik na funkcję przyjmującą int i zwracającą int
int *g(int);     // FUNKCJA przyjmująca int i zwracająca int*, coś zupełnie innego

Tak to działa od początku do końca:

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    int (*op)(int, int);        // deklaracja

    op = add;                   // przypisanie (bez &)
    printf("add:      %d\n", op(10, 3));

    op = subtract;              // wskaż coś innego
    printf("subtract: %d\n", op(10, 3));

    op = &multiply;             // & jest dozwolone, ale zbędne
    printf("multiply: %d\n", (*op)(10, 3));   // ta forma wywołania też

    printf("\nsama funkcja lezy pod adresem %p\n", (void *)(void (*)(void))add);
    return 0;
}

Obie formy wywołania działają, bo nazwa funkcji automatycznie zamienia się we wskaźnik. Pisz op(10, 3); zapis (*op)(10, 3) to pozostałość po dawnych czasach.

Jedna uwaga do ostatniego printf: %p oczekuje wskaźnika na obiekt, a wskaźniki na funkcje formalnie należą do osobnej rodziny, więc wypisanie takiego wskaźnika nie jest w pełni przenośne. Rzutowanie ucisza kompilatory na platformach, na których to w ogóle działa; rzadko będziesz tego potrzebować.

typedef poprawia czytelność

Składnia deklaracji szybko robi się brzydka, a standardowym lekarstwem jest typedef:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = wskaźnik na int(int,int)

int add(int a, int b)      { return a + b; }
int multiply(int a, int b) { return a * b; }

// funkcja przyjmująca funkcję czyta się teraz jak każda inna deklaracja
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

Porównaj int apply(BinaryOp op, int x, int y) z surową formą int apply(int (*op)(int, int), int x, int y). Znaczenie jest to samo, ale tylko jedną z nich przeczytasz jednym rzutem oka. Ogólne zasady znajdziesz na stronie o typedef.

Callbacki: zachowanie dostarcza wywołujący

Callback to funkcja, którą przekazujesz innej funkcji, żeby mogła cię wywołać we właściwym momencie. Dzięki temu jeden fragment kodu zajmuje się strukturą zadania, a wywołujący dostarcza decyzję.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// jedna funkcja, dowolny test
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("parzyste:  %d\n", count_if(data, n, is_even));
    printf("dodatnie:  %d\n", count_if(data, n, is_positive));
    printf("duze:      %d\n", count_if(data, n, is_big));

    return 0;
}

Bez wskaźników na funkcje trzeba by napisać count_even, count_positive i count_big, czyli trzy kopie tej samej pętli. Z nimi pętla powstaje raz, a parametrem jest test.

Prawdziwa korzyść: qsort

Funkcja qsort z biblioteki standardowej to przykład wskaźnika na funkcję, którego naprawdę będziesz używać. Sortuje tablicę czegokolwiek, a udaje się jej to dlatego, że o elementach nie wie nic poza ich rozmiarem i komparatorem, który dostarczasz.

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

Komparator dostaje dwa const void *, czyli adresy dwóch elementów, i zwraca liczbę ujemną, jeśli pierwszy ma być przed drugim, zero przy remisie i liczbę dodatnią, jeśli ma być po nim.

#include <stdio.h>
#include <stdlib.h>

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // rzutuj z powrotem na prawdziwy typ, potem czytaj
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // zamień argumenty, żeby odwrócić kolejność
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("rosnaco:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\nmalejaco: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

Z tego komparatora warto wynieść dwa nawyki. Nigdy nie pisz return x - y;: wygląda sprytnie, ale przepełnia się dla dużych albo ujemnych wartości, daje zły znak i źle posortowaną tablicę. Rzutuj przed wyłuskaniem, a nie po nim: *(const int *)a, bo *a na void * nie ma czego odczytać.

Ten sam mechanizm sortuje struktury według dowolnego pola:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // najwyższy pierwszy
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("wedlug wyniku:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("wedlug imienia:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

Idiom (q->score > p->score) - (q->score < p->score) zwraca dokładnie -1, 0 albo 1 bez odejmowania wartości i bez przepełnienia. A strcmp ma już właściwą konwencję wartości zwracanej, więc komparator łańcuchów mieści się w jednej linii.

Tablice wskaźników na funkcje

Tablica wskaźników na funkcje zamienia łańcuch if/else w wyszukiwanie. Tak interpretery wybierają kod operacji, a systemy menu uruchamiają polecenia.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "dodawanie"},
        {'-', op_sub, "odejmowanie"},
        {'*', op_mul, "mnozenie"},
        {'/', op_div, "dzielenie"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // wybór według znaku, bez switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\nwybrano '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Dodanie operacji to teraz dodanie wiersza, a nie edycja switch. Połącz to ze strukturami, a dostaniesz standardowy kształt wtyczki w C: struktura wskaźników na funkcje to w tym języku odpowiednik "interfejsu".

Na co uważać

Sygnatury muszą pasować dokładnie. Typ wskaźnika na funkcję obejmuje typy parametrów i typ zwracany. Przypisanie niepasującej funkcji narusza ograniczenia języka, a wywołanie przez wskaźnik złego typu to niezdefiniowane zachowanie, nawet jeśli "działa". Nie rzutuj sygnatury komparatora, żeby uciszyć ostrzeżenie: popraw komparator.

Pusty wskaźnik na funkcję to nadal pusty wskaźnik. Inicjalizuj go wartością NULL i sprawdzaj przed wywołaniem, dokładnie tak jak wskaźniki na dane:

if (handler != NULL) {
    handler(event);
}

Na stronie o pustych wskaźnikach przeczytasz, dlaczego to sprawdzenie się opłaca.

Wskaźniki void tracą bezpieczeństwo typów i to ty jesteś systemem typów. Wewnątrz komparatora qsort nic nie powstrzyma cię przed rzutowaniem na zły typ. Jeśli posortujesz tablicę double przez compare_ints, kod skompiluje się bez zastrzeżeń i da bzdury.

Składnia deklaratorów się zagnieżdża. Funkcja zwracająca wskaźnik na funkcję to int (*get_op(char c))(int, int);. Gdy łapiesz się na pisaniu czegoś takiego, sięgnij po typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // to samo, ale czytelnie