Funktionszeiger in C: Syntax, Callbacks und qsort

Übersetzter Code liegt genauso im Speicher wie Daten, eine Funktion hat also eine Adresse. Ein Funktionszeiger ist eine Variable, die eine solche speichert - und sobald du eine Funktion speichern kannst, kannst du eine als Argument übergeben, eine Tabelle davon halten oder zur Laufzeit zwischen ihnen wählen.

Das ist die Fähigkeit hinter Sortieren mit eigener Ordnung, Ereignisbehandlern, Plugin-Schnittstellen und Zustandsmaschinen. Es ist zugleich das Stück C-Syntax, bei dem ein Leser am ehesten innehält und die Augen zusammenkneift, also fangen wir dort an.

Die Deklarationssyntax

Nimm eine gewöhnliche Funktion:

int add(int a, int b);

Um einen Zeiger zu deklarieren, der ihre Adresse fassen kann, ersetze den Namen durch (*name):

int (*op)(int, int);

Lies es von innen: op ist ein Zeiger auf eine Funktion, die (int, int) nimmt und int liefert.

Die Klammern sind keine Zierde. Ohne sie bindet das * an den Rückgabetyp:

int (*f)(int);   // Zeiger auf eine Funktion, die int nimmt und int liefert
int *g(int);     // FUNKTION, die int nimmt und int* liefert - völlig anders

Hier funktioniert es von Anfang bis Ende:

#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);        // deklarieren

    op = add;                   // zuweisen (kein & noetig)
    printf("addieren:      %d\n", op(10, 3));

    op = subtract;              // woanders hin zeigen lassen
    printf("subtrahieren:  %d\n", op(10, 3));

    op = &multiply;             // das & ist erlaubt, aber ueberfluessig
    printf("multiplizieren: %d\n", (*op)(10, 3));   // diese Aufrufform auch

    printf("\ndie Funktion selbst liegt bei %p\n", (void *)(void (*)(void))add);
    return 0;
}

Beide Aufrufformen funktionieren, weil sich ein Funktionsbezeichner automatisch in einen Zeiger umwandelt. Schreibe op(10, 3); die Schreibweise (*op)(10, 3) ist ein Überbleibsel.

Eine Anmerkung zum letzten printf: %p erwartet einen Objektzeiger, und Funktionszeiger sind formal eine eigene Familie, einen davon auszugeben ist also nicht streng portabel. Der Cast hält Compiler auf den Plattformen ruhig, auf denen es überhaupt geht; du wirst selten einen ausgeben müssen.

typedef macht es lesbar

Die Deklarationssyntax wird schnell hässlich, und typedef ist das übliche Gegenmittel:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = Zeiger auf int(int,int)

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

// jetzt liest sich eine Funktion, die eine Funktion nimmt, wie jede andere Deklaration
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;
}

Vergleiche int apply(BinaryOp op, int x, int y) mit der rohen Form int apply(int (*op)(int, int), int x, int y). Dieselbe Bedeutung; eine davon kannst du auf einen Blick lesen. Siehe typedef für die allgemeinen Regeln.

Callbacks: den Aufrufer das Verhalten liefern lassen

Ein Callback ist eine Funktion, die du einer anderen Funktion reichst, damit sie dich im richtigen Moment zurückrufen kann. So kann ein Stück Code die Struktur einer Aufgabe übernehmen, während der Aufrufer die Entscheidung liefert.

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

// eine Funktion, beliebiger 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("gerade:  %d\n", count_if(data, n, is_even));
    printf("positiv: %d\n", count_if(data, n, is_positive));
    printf("gross:   %d\n", count_if(data, n, is_big));

    return 0;
}

Ohne Funktionszeiger würdest du count_even, count_positive und count_big schreiben - drei Kopien derselben Schleife. Mit ihnen wird die Schleife einmal geschrieben und der Test ist der Parameter.

Der eigentliche Gewinn: qsort

qsort aus der Standardbibliothek ist das Funktionszeiger-Beispiel, das du tatsächlich benutzen wirst. Es sortiert ein Array von irgendetwas, und das gelingt, weil es über die Elemente nichts weiß außer ihrer Größe und einem Vergleicher, den du lieferst.

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

Der Vergleicher erhält zwei const void * - die Adressen zweier Elemente - und liefert eine negative Zahl, wenn das erste vor dem zweiten einsortiert wird, null bei Gleichstand, positiv, wenn es danach kommt.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // zurueck in den echten Typ casten, dann lesen
    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);    // Argumente tauschen kehrt die Reihenfolge um
}

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("aufsteigend: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

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

    return 0;
}

Zwei Gewohnheiten aus diesem Vergleicher. Schreibe nie return x - y; - es sieht clever aus und läuft bei großen oder negativen Werten über, was ein falsches Vorzeichen und ein fehlsortiertes Array ergibt. Caste vor dem Dereferenzieren, nicht danach: *(const int *)a, denn *a auf einem void * hat nichts zu lesen.

Dieselbe Maschinerie sortiert Strukturen nach jedem Feld, das du magst:

#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);   // hoechste zuerst
}

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("nach Punkten:\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("nach Namen:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

Das Idiom (q->score > p->score) - (q->score < p->score) liefert genau -1, 0 oder 1 ohne Subtraktion und ohne Überlauf. Und strcmp hat bereits die richtige Rückgabekonvention, ein Zeichenketten-Vergleicher ist also ein Einzeiler.

Tabellen von Funktionszeigern

Ein Array von Funktionszeigern macht aus einer Kette von if/else ein Nachschlagen. So verteilen Interpreter Opcodes und so führen Menüsysteme Befehle aus.

#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, "addieren"},
        {'-', op_sub, "subtrahieren"},
        {'*', op_mul, "multiplizieren"},
        {'/', op_div, "dividieren"}
    };
    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);
    }

    // ueber ein Zeichen verteilen, ohne switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\n'%c' verteilt -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Eine Operation hinzuzufügen heißt jetzt, eine Zeile hinzuzufügen, statt ein switch zu bearbeiten. Kombiniere das mit Strukturen, und du hast die übliche C-Plugin-Form: Eine Struktur aus Funktionszeigern ist das, was „eine Schnittstelle" in dieser Sprache bedeutet.

Dinge, die beißen

Signaturen müssen exakt passen. Der Typ eines Funktionszeigers schließt seine Parametertypen und seinen Rückgabetyp ein. Eine unpassende Funktion zuzuweisen ist eine Verletzung der Sprachregeln, und ein Aufruf über einen falsch typisierten Zeiger ist undefiniertes Verhalten, auch wenn es „funktioniert". Caste nicht die Signatur eines Vergleichers, um eine Warnung zum Schweigen zu bringen - repariere den Vergleicher.

Ein Null-Funktionszeiger ist immer noch ein Nullzeiger. Initialisiere mit NULL und prüfe vor dem Aufruf, genau wie bei Datenzeigern:

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

Siehe Nullzeiger, warum diese Prüfung ihr Geld wert ist.

void-Zeiger verlieren die Typsicherheit, und du bist das Typsystem. In einem qsort-Vergleicher hindert dich nichts daran, in den falschen Typ zu casten. Sortierst du ein Array von double mit compare_ints, kompiliert es sauber und produziert Unsinn.

Die Deklaratorsyntax verschachtelt sich. Eine Funktion, die einen Funktionszeiger liefert, ist int (*get_op(char c))(int, int);. Wenn du dich dabei ertappst, das zu schreiben, greif zu typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // dasselbe, lesbar