Multi-fichero en C: headers, macros y depuración

1. El preprocesador

Se ejecuta antes de compilar y trabaja con texto. Todas sus líneas empiezan por #.

#include <stdio.h>        // busca en las carpetas del sistema (librerías estándar)
#include "mates.h"        // busca primero en tu carpeta (tus headers)

#define MAX_ALUMNOS 30            // constante: se sustituye el texto
#define MAX(a, b) (((a) > (b)) ? (a) : (b))   // macro con parámetros

#ifdef DEBUG                      // compilación condicional
    printf("depuracion: x=%d\n", x);
#endif

Compila con depuración activa: gcc -DDEBUG prog.c.

Macros: la trampa del texto

#define CUADRADO(x) x*x
CUADRADO(a+b)      // → a+b*a+b   ¡mal!
#define CUADRADO(x) ((x) * (x))    // parentesis en cada parametro y en el total

Y aún así: CUADRADO(i++) evalúa i++ dos veces. Para funciones simples prefiere static inline.

2. Dividir en ficheros: .h y .c

mates.h

#ifndef MATES_H          // include guard
#define MATES_H

int cuadrado(int x);

#endif

mates.c

#include "mates.h"       // comprueba que firma y definición coinciden
int cuadrado(int x) { return x * x; }

main.c

#include <stdio.h>
#include "mates.h"
int main(void) { printf("%d\n", cuadrado(5)); }

Compilar:

gcc -Wall -Wextra main.c mates.c -o prog

Los include guards

#ifndef X / #define X / #endif evitan que un header se procese dos veces si lo incluyen varios ficheros (daría errores de "redefinición").

Compilar por separado (proyectos grandes)

gcc -c main.c            # → main.o  (solo compila)
gcc -c mates.c           # → mates.o
gcc main.o mates.o -o prog   # enlaza

Así, si solo cambias mates.c, solo recompilas ése. Eso automatiza make:

prog: main.o mates.o
    gcc main.o mates.o -o prog
%.o: %.c
    gcc -Wall -Wextra -c $< -o $@

(Las líneas de comandos empiezan con TAB.)

static y extern

• static en una función/variable global: privada de ese .c.
• extern int contador; en el .h + int contador; en un solo .c: variable global compartida (úsalo con moderación).

Tipos opacos (TAD)

En el header: typedef struct Pila Pila; y solo las funciones. El struct Pila {...} completo se define en pila.c. Los usuarios no pueden tocar los campos → puedes cambiar la implementación sin romper nada (lo harás en el módulo 12).

3. Errores típicos de enlace

4. Depuración: el método científico

Cuando un programa compila pero da resultados erróneos:

1. Reproduce el fallo con el ejemplo más pequeño posible.
2. Predice a mano qué debería pasar, paso a paso.
3. Observa: pon printf (a stderr) en puntos clave y compara lo previsto con lo real. El primer punto donde difieren acota el bug.
4. Una hipótesis cada vez: cambia una cosa, prueba, repite.
5. Explícaselo a un patito de goma 🦆: dicho en voz alta, el error salta solo.

Herramientas: * Warnings: -Wall -Wextra (¡léelos!). * Sanitizers: -fsanitize=address,undefined -g detecta desbordamientos, use-after-free, UB aritmético. * Depurador gdb: gcc -g prog.c -o prog && gdb ./prog → break main, run, next, step, print x, bt (traza tras un crash), watch x, quit. * assert: #include <assert.h>; assert(n > 0); aborta con el sitio exacto si se rompe una suposición.

Bugs típicos de lógica

Off-by-one en bucles · confundir = y == · división entera · índices desde 0 vs 1 · variable sin inicializar · olvidar el \0.

Prueba esto

1. Convierte uno de tus ejercicios previos en proyecto de 3 ficheros.
2. Escribe un Makefile y ejecuta make.
3. Mete a propósito un a[10] en un array de 5 y compila con -fsanitize=address para ver el informe.