C Academy · Lektion

Tabellen mit Funktionszeigern

Dispatch-Muster

Tabellen mit Funktionszeigern ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Tabellen von Funktionen

Sie können Funktionszeiger in einem Array speichern, um eine Dispatch-Tabelle zu erstellen. Ein Index oder Code wählt die auszuführende Funktion aus und ersetzt lange Ketten aus if-else oder switch.

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main(void) {
    int (*ops[2])(int,int) = { add, sub };
    printf("%d\n", ops[0](5, 3));
    printf("%d\n", ops[1](5, 3));
    return 0;
}

Die Tabelle indizieren

Wählen Sie eine Operation zur Laufzeit aus, indem Sie das Array indizieren. Der Index kann aus einer Benutzereingabe oder dem Programmzustand stammen.

#include <stdio.h>

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

int main(void) {
    int (*ops[2])(int,int) = { add, mul };
    int choice = 1;
    printf("%d\n", ops[choice](6, 7));
    return 0;
}

Ein switch ersetzen

Eine Dispatch-Tabelle ist oft übersichtlicher als ein switch, wenn jeder Fall lediglich eine Funktion aufruft.

#include <stdio.h>

void start(void) { printf("start\n"); }
void stop(void)  { printf("stop\n"); }
void pause(void) { printf("pause\n"); }

int main(void) {
    void (*table[3])(void) = { start, stop, pause };
    for (int i = 0; i < 3; i++) table[i]();
    return 0;
}

typedef macht die Tabelle übersichtlicher

Mit einem typedef für den Funktionszeigertyp wird die Deklaration der Tabelle kurz und gut lesbar.

#include <stdio.h>

typedef int (*BinOp)(int,int);

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main(void) {
    BinOp ops[] = { add, sub };
    printf("%d\n", ops[0](10, 4));
    return 0;
}

Symbole Funktionen zuordnen

Ordnen Sie jedem Operatorsymbol seine Funktion zu, indem Sie parallele Arrays oder eine Strukturtabelle verwenden, die Sie nach Namen durchsuchen können.

#include <stdio.h>

typedef int (*BinOp)(int,int);

int add(int a, int b){return a+b;}
int sub(int a, int b){return a-b;}

int main(void) {
    char syms[] = {'+', '-'};
    BinOp ops[] = { add, sub };
    char want = '-';
    for (int i = 0; i < 2; i++)
        if (syms[i] == want) printf("%d\n", ops[i](9, 2));
    return 0;
}

Eine befehlsbasierte Strukturtabelle

Bündeln Sie einen Namen und einen Handler in einer Struktur und erstellen Sie anschließend ein Array daraus. Dies ist das klassische Muster einer Befehlstabelle.

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

typedef struct {
    const char *name;
    void (*run)(void);
} Command;

void hello(void){printf("hi\n");}
void bye(void){printf("bye\n");}

int main(void) {
    Command cmds[] = {{"hello", hello}, {"bye", bye}};
    const char *input = "bye";
    for (int i = 0; i < 2; i++)
        if (strcmp(cmds[i].name, input) == 0) cmds[i].run();
    return 0;
}

Grenzen prüfen

Prüfen Sie immer den Index, bevor Sie über die Tabelle einen Aufruf durchführen, damit Sie nicht hinter das Array hinauslesen.

#include <stdio.h>

typedef int (*Fn)(int);
int sq(int x){return x*x;}
int neg(int x){return -x;}

int main(void) {
    Fn table[] = { sq, neg };
    int n = 2;
    int idx = 5;
    if (idx >= 0 && idx < n) printf("%d\n", table[idx](3));
    else printf("index out of range\n");
    return 0;
}

Zustandsautomaten

Dispatch-Tabellen steuern Zustandsautomaten: Jeder Zustand ist ein Funktionszeiger, und die Handler geben den Index des nächsten Zustands zurück.

#include <stdio.h>

int state_a(void){ printf("A\n"); return 1; }
int state_b(void){ printf("B\n"); return -1; }

int main(void) {
    int (*states[2])(void) = { state_a, state_b };
    int s = 0;
    while (s >= 0) s = states[s]();
    return 0;
}

Plugin-ähnliche Dispatch-Tabelle

Wenn Sie Handler in einer Tabelle registrieren, können Sie neues Verhalten hinzufügen, indem Sie einen Eintrag ergänzen, statt einen großen switch zu bearbeiten.

#include <stdio.h>

typedef void (*Handler)(int);
void log_low(int v){printf("low %d\n", v);}
void log_high(int v){printf("high %d\n", v);}

int main(void) {
    Handler handlers[] = { log_low, log_high };
    int level = 1;
    handlers[level](7);
    return 0;
}

Standard-Handler

Reservieren Sie einen Eintrag oder einen Ersatzzeiger für unbekannte Codes, damit die Dispatch-Tabelle niemals unbemerkt fehlschlägt.

#include <stdio.h>

typedef void (*Fn)(void);
void known(void){printf("known\n");}
void fallback(void){printf("unknown command\n");}

int main(void) {
    Fn table[] = { known };
    int n = 1, code = 9;
    Fn f = (code >= 0 && code < n) ? table[code] : fallback;
    f();
    return 0;
}

Warum Tabellen skalierbar sind

Dispatch-Tabellen verwandeln Verzweigungslogik in eine Datensuche. Das Hinzufügen von Fällen bedeutet das Hinzufügen von Daten. Dadurch bleibt der Code übersichtlich und schnell.

#include <stdio.h>

typedef int (*Fn)(int);
int a(int x){return x+1;}
int b(int x){return x*2;}
int c(int x){return x*x;}

int main(void) {
    Fn t[] = { a, b, c };
    for (int i = 0; i < 3; i++) printf("%d ", t[i](4));
    printf("\n");
    return 0;
}

Kurzer Test

Testen Sie Ihr Verständnis von Tabellen mit Funktionszeigern.

Zusammenfassung

Sie haben Dispatch-Muster mit Tabellen aus Funktionszeigern kennengelernt:

Speichern Sie Funktionszeiger in einem Array und wählen Sie sie über einen Index aus.
Sie ersetzen lange switch-Ketten und lassen sich durch das Hinzufügen von Daten erweitern.
Verwenden Sie typedef und Befehlstabellen auf Strukturbasis für mehr Übersichtlichkeit.
Prüfen Sie immer die Grenzen des Index und stellen Sie einen Standard-Handler bereit.

Häufig gestellte Fragen

Ist die Lektion „Tabellen mit Funktionszeigern“ kostenlos?

Ja — der vollständige Text von „Tabellen mit Funktionszeigern“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Tabellen mit Funktionszeigern“?

Dispatch-Muster Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Tabellen mit Funktionszeigern“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy