C Academy · Lekcja

Tabele wskaźników do funkcji

Wzorce dyspozytora

Tabele wskaźników do funkcji to bezpłatna lekcja C Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C Academy zawiera 4 lekcji w sumie.

Tablice funkcji

Wskaźniki do funkcji można przechowywać w tablicy, tworząc tablicę dyspozytorską. Indeks lub kod wybiera funkcję do uruchomienia, zastępując długie łańcuchy if-else lub instrukcje 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;
}

Indeksowanie tablicy

Wybierz operację w czasie działania programu, indeksując tablicę. Indeks może pochodzić od użytkownika lub ze stanu programu.

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

Zastępowanie switch

Tablica dyspozytorska jest często czytelniejsza niż switch, gdy każdy przypadek tylko wywołuje funkcję.

#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 porządkuje tablicę

Użycie typedef dla typu wskaźnika do funkcji skraca deklarację tablicy i poprawia jej czytelność.

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

Mapowanie symboli na funkcje

Połącz każdy symbol operatora z jego funkcją w równoległych tablicach lub w tablicy struktur, aby wyszukiwać funkcję po nazwie.

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

Tablica poleceń oparta na strukturze

Połącz nazwę i funkcję obsługi w strukturze, a następnie utwórz ich tablicę. Jest to klasyczny wzorzec tablicy poleceń.

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

Sprawdzanie zakresu

Zawsze sprawdzaj poprawność indeksu przed wywołaniem funkcji przez tablicę, aby uniknąć odczytu poza jej końcem.

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

Maszyny stanów

Tablice dyspozytorskie sterują maszynami stanów: każdy stan jest wskaźnikiem do funkcji, a funkcje obsługi zwracają indeks następnego stanu.

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

Dyspozytornia przypominająca wtyczki

Rejestrowanie funkcji obsługi w tablicy pozwala dodawać nowe działanie przez dopisanie wpisu, zamiast modyfikowania dużej instrukcji switch.

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

Domyślna funkcja obsługi

Zarezerwuj jeden element lub wskaźnik awaryjny dla nieznanych kodów, aby dyspozytornia nigdy nie kończyła działania bez komunikatu.

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

Dlaczego tablice dobrze się skalują

Tablice dyspozytorskie zamieniają logikę rozgałęzień na wyszukiwanie danych. Dodawanie przypadków oznacza dodawanie danych, dzięki czemu kod pozostaje płaski i szybki.

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

Szybki sprawdzian

Sprawdź swoją wiedzę o tablicach wskaźników do funkcji.

Podsumowanie

Dowiedział się Pan / Dowiedziała się Pani o wzorcach dyspozytorskich z użyciem tablic wskaźników do funkcji:

Przechowuj wskaźniki do funkcji w tablicy i wybieraj je według indeksu.
Zastępują one długie łańcuchy switch i skalują się przez dodawanie danych.
Używaj typedef oraz tablic poleceń opartych na strukturach, aby zwiększyć czytelność.
Zawsze sprawdzaj indeks pod kątem zakresu i zapewniaj domyślną funkcję obsługi.

Często zadawane pytania

Czy lekcja „Tabele wskaźników do funkcji” jest bezpłatna?

Tak — pełny tekst „Tabele wskaźników do funkcji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C Academy, przejdź na CoddyKit PRO. Kurs C Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Tabele wskaźników do funkcji”?

Wzorce dyspozytora Ćwiczysz C Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C Academy?

Nie wymagamy żadnego doświadczenia. C Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Tabele wskaźników do funkcji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C Academy?

Tak. Każda lekcja C Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C Academy