0Pricing
C Academy · Lezione

Tabelle di puntatori a funzione

Pattern di dispatch

Tabelle di puntatori a funzione è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Tabelle di funzioni

È possibile memorizzare puntatori a funzione in un array per creare una tabella di dispatch. Un indice o un codice seleziona la funzione da eseguire, sostituendo lunghe catene di if-else o 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;
}

Indicizzare la tabella

Scelga un'operazione durante l'esecuzione indicizzando l'array. L'indice può provenire dall'input dell'utente o dallo stato del programma.

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

Sostituire uno switch

Una tabella di dispatch è spesso più chiara di uno switch quando ogni caso si limita a chiamare una funzione.

#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 semplifica la tabella

Utilizzare un typedef per il tipo puntatore a funzione rende la dichiarazione della tabella breve e leggibile.

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

Associare i simboli alle funzioni

Abbini ogni simbolo di operatore alla relativa funzione in array paralleli o in una tabella di struct, per effettuare la ricerca in base al nome.

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

Una tabella di comandi basata su struct

Raggruppi un nome e un gestore in una struct, quindi ne crei un array. Questo è il classico modello della tabella di comandi.

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

Controllare i limiti

Convalidi sempre l'indice prima di chiamare una funzione tramite la tabella, per evitare di leggere oltre la fine dell'array.

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

Macchine a stati

Le tabelle di dispatch pilotano le macchine a stati: ogni stato è rappresentato da un puntatore a funzione e i gestori restituiscono l'indice dello stato successivo.

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

Dispatch simile a quello dei plugin

Registrando i gestori in una tabella, è possibile aggiungere nuove funzionalità accodando una voce invece di modificare un grande 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;
}

Gestore predefinito

Riservi uno slot o un puntatore di fallback per i codici sconosciuti, così il dispatch non fallisce in modo silenzioso.

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

Perché le tabelle sono scalabili

Le tabelle di dispatch trasformano la logica condizionale in una ricerca nei dati. Aggiungere casi significa aggiungere dati, mantenendo il codice lineare e veloce.

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

Verifica rapida

Verifichi la Sua comprensione delle tabelle di puntatori a funzione.

Riepilogo

Ha imparato i modelli di dispatch con le tabelle di puntatori a funzione:

  • Memorizzare i puntatori a funzione in un array e selezionarli tramite indice.
  • Sostituiscono lunghe catene di switch e sono scalabili aggiungendo dati.
  • Utilizzare typedef e tabelle di comandi basate su struct per maggiore chiarezza.
  • Controllare sempre i limiti dell'indice e fornire un gestore predefinito.

Domande Frequenti

La lezione «Tabelle di puntatori a funzione» è gratuita?

Sì — il testo completo di «Tabelle di puntatori a funzione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Tabelle di puntatori a funzione»?

Pattern di dispatch Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Tabelle di puntatori a funzione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Dichiarare puntatori a funzione
  2. Passare funzioni
  3. qsort con comparatori
  4. Tabelle di puntatori a funzione
← Torna a C Academy