C Academy · Les

Tabellen met functiepointers

Dispatchpatronen

Les 4 van 413 stappen

Tabellen met functiepointers is een gratis C Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.

Functietabellen

Je kunt functiepointers in een array opslaan om een dispatchetabel te bouwen. Met een index of code selecteer je welke functie wordt uitgevoerd, waardoor lange if-else- of switch-ketens overbodig worden.

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

De tabel indexeren

Kies tijdens runtime een bewerking door de array te indexeren. De index kan afkomstig zijn van gebruikersinvoer of de programmatoestand.

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

Een switch vervangen

Een dispatchetabel is vaak duidelijker dan een switch wanneer elke case alleen een functie aanroept.

#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 maakt de tabel overzichtelijker

Als je een typedef gebruikt voor het type van de functiepointer, wordt de declaratie van de tabel kort en leesbaar.

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

Symbolen aan functies koppelen

Koppel elk operator-symbool aan zijn functie in parallelle arrays of een structtabel, zodat je de functie op naam kunt opzoeken.

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

Een op structs gebaseerde commandotabel

Bundel een naam en een handler in een struct en maak daar vervolgens een array van. Dit is het klassieke patroon voor commandotabellen.

#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 controleren

Controleer de index altijd voordat je via de tabel een functie aanroept, zodat je niet voorbij het einde van de array leest.

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

Toestandsmachines

Dispatchetabels sturen toestandsmachines aan: elke toestand is een functiepointer en handlers retourneren de index van de volgende toestand.

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

Pluginachtige dispatch

Door handlers in een tabel te registreren, kun je nieuw gedrag toevoegen door een item achteraan toe te voegen in plaats van een grote switch te bewerken.

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

Standaardhandler

Reserveer één plaats of een fallbackpointer voor onbekende codes, zodat dispatch nooit stilletjes mislukt.

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

Waarom tabellen schaalbaar zijn

Dispatchetabels veranderen vertakkingslogica in een opzoeking in gegevens. Nieuwe cases toevoegen betekent gegevens toevoegen, waardoor de code vlak en snel blijft.

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

Korte controle

Test je begrip van tabellen met functiepointers.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt dispatchpatronen met tabellen van functiepointers geleerd:

Sla functiepointers op in een array en selecteer ze op index.
Ze vervangen lange switch-ketens en schalen door gegevens toe te voegen.
Gebruik typedef en struct-gebaseerde commandotabellen voor duidelijkheid.
Controleer altijd de grenzen van de index en geef een standaardhandler op.

Gratis beginnen

Leer C met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Tabellen met functiepointers” gratis?

Ja — de volledige tekst van “Tabellen met functiepointers” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.

Wat leer ik in “Tabellen met functiepointers”?

Dispatchpatronen Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C Academy te beginnen?

Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Tabellen met functiepointers”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C Academy?

Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C Academy