0Pricing
C Academy · Leçon

Tables de pointeurs de fonctions

Motifs de répartition

Tables de pointeurs de fonctions est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Tables de fonctions

Vous pouvez stocker des pointeurs de fonction dans un tableau pour créer une table de dispatch. Un indice ou un code sélectionne la fonction à exécuter, ce qui remplace de longues chaînes de if-else ou de 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;
}

Indexer la table

Choisissez une opération à l'exécution en indexant le tableau. L'indice peut provenir de la saisie de l'utilisateur ou de l'état du programme.

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

Remplacer un switch

Une table de dispatch est souvent plus claire qu'un switch lorsque chaque cas ne fait qu'appeler une fonction.

#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 simplifie la table

Utiliser un typedef pour le type de pointeur de fonction rend la déclaration de la table courte et lisible.

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

Associer des symboles à des fonctions

Associez chaque symbole d'opérateur à sa fonction dans des tableaux parallèles ou une table de structures afin d'effectuer une recherche par nom.

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

Une table de commandes fondée sur une structure

Regroupez un nom et un gestionnaire dans une structure, puis créez-en un tableau. Il s'agit du modèle classique de table de commandes.

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

Vérification des limites

Validez toujours l'indice avant d'appeler une fonction via la table afin d'éviter de lire au-delà du tableau.

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

Machines à états

Les tables de dispatch pilotent les machines à états : chaque état est un pointeur de fonction et les gestionnaires renvoient l'indice de l'état suivant.

#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 semblable à celui des modules d'extension

En enregistrant les gestionnaires dans une table, vous pouvez ajouter un nouveau comportement en ajoutant une entrée plutôt qu'en modifiant un grand 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;
}

Gestionnaire par défaut

Réservez un emplacement ou un pointeur de remplacement pour les codes inconnus afin que le dispatch n'échoue jamais silencieusement.

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

Pourquoi les tables passent à l'échelle

Les tables de dispatch transforment la logique conditionnelle en recherche de données. Ajouter des cas revient à ajouter des données, ce qui conserve un code linéaire et rapide.

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

Vérification rapide

Vérifiez votre compréhension des tables de pointeurs de fonction.

Récapitulatif

Vous avez découvert les modèles de dispatch avec des tables de pointeurs de fonction :

  • Stockez les pointeurs de fonction dans un tableau et sélectionnez-les par indice.
  • Ils remplacent les longues chaînes de switch et évoluent par ajout de données.
  • Utilisez typedef et des tables de commandes fondées sur des structures pour plus de clarté.
  • Vérifiez toujours les limites de l'indice et fournissez un gestionnaire par défaut.

Questions Fréquemment Posées

La leçon « Tables de pointeurs de fonctions » est-elle gratuite ?

Oui — le texte complet de « Tables de pointeurs de fonctions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tables de pointeurs de fonctions » ?

Motifs de répartition Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Tables de pointeurs de fonctions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Déclarer des pointeurs de fonctions
  2. Transmettre des fonctions
  3. qsort avec comparateurs
  4. Tables de pointeurs de fonctions
← Retour à C Academy