0Pricing
C Academy · Lección

Tablas de punteros a funciones

Patrones de despacho

Tablas de punteros a funciones es una lección gratuita de C Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

Tablas de funciones

Puede almacenar punteros a función en un array para crear una tabla de despacho. Un índice o código selecciona qué función ejecutar, sustituyendo largas cadenas de 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;
}

Indexar la tabla

Elija una operación durante la ejecución indexando el array. El índice puede proceder de la entrada del usuario o del estado del programa.

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

Sustituir un switch

Una tabla de despacho suele ser más clara que un switch cuando cada caso solo llama a una función.

#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 simplifica la tabla

Usar un typedef para el tipo de puntero a función hace que la declaración de la tabla sea breve y legible.

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

Asignar símbolos a funciones

Asocie cada símbolo de operador con su función en arrays paralelos o en una tabla de estructuras para poder buscarlo por nombre.

#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 tabla de comandos basada en estructuras

Agrupe un nombre y un controlador en una estructura y cree después un array con ellos. Este es el patrón clásico de tabla de comandos.

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

Comprobar los límites

Valide siempre el índice antes de llamar mediante la tabla para evitar leer más allá del 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;
}

Máquinas de estados

Las tablas de despacho controlan máquinas de estados: cada estado es un puntero a función y los controladores devuelven el índice del estado siguiente.

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

Despacho similar al de plugins

Al registrar controladores en una tabla, puede añadir nuevos comportamientos agregando una entrada en lugar de editar un switch grande.

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

Controlador predeterminado

Reserve una posición o un puntero alternativo para los códigos desconocidos, de modo que el despacho nunca falle silenciosamente.

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

Por qué las tablas escalan

Las tablas de despacho convierten la lógica de bifurcación en una búsqueda de datos. Añadir casos significa añadir datos, lo que mantiene el código plano y rápido.

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

Comprobación rápida

Compruebe su comprensión de las tablas de punteros a función.

Resumen

Ha aprendido patrones de despacho con tablas de punteros a función:

  • Almacene punteros a función en un array y selecciónelos mediante un índice.
  • Sustituyen largas cadenas de switch y escalan al añadir datos.
  • Use typedef y tablas de comandos basadas en estructuras para mejorar la claridad.
  • Compruebe siempre los límites del índice y proporcione un controlador predeterminado.

Preguntas frecuentes

¿La lección «Tablas de punteros a funciones» es gratis?

Sí — el texto completo de «Tablas de punteros a funciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tablas de punteros a funciones»?

Patrones de despacho Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Tablas de punteros a funciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Declaración de punteros a funciones
  2. Paso de funciones
  3. qsort con comparadores
  4. Tablas de punteros a funciones
← Volver a C Academy