Entendiendo los Archivos de Cabecera en C: Tipos, Uso y Buenas Prácticas

Un archivo de cabecera es un archivo con extensión .h que contiene declaraciones de funciones de C y definiciones de macros para ser compartidas entre varios archivos fuente. Existen dos tipos de archivos de cabecera: los que escribe el programador y los que vienen con el compilador.

Se solicita el uso de un archivo de cabecera en el programa incluyéndolo con la directiva de preprocesamiento #include, como ha visto con la inclusión del archivo de cabecera stdio.h, que viene con el compilador.

Incluir un archivo de cabecera equivale a copiar su contenido, pero no lo hacemos porque sería propenso a errores y no es buena idea copiar el contenido de un archivo de cabecera en los archivos fuente, especialmente si tenemos múltiples archivos fuente en un programa.

Una práctica sencilla en programas C o C++ es mantener todas las constantes, macros, variables globales del sistema y prototipos de funciones en los archivos de cabecera e incluir ese archivo de cabecera donde sea necesario.

Sintaxis de Inclusión

Tanto los archivos de cabecera del usuario como los del sistema se incluyen usando la directiva de preprocesamiento #include. Tiene las siguientes dos formas:

#include <archivo>

Esta forma se usa para archivos de cabecera del sistema. Busca un archivo llamado 'archivo' en una lista estándar de directorios del sistema. Puede anteponer directorios a esta lista con la opción -I al compilar su código fuente.

#include "archivo"

Esta forma se usa para archivos de cabecera de su propio programa. Busca un archivo llamado 'archivo' en el directorio que contiene el archivo actual. También puede anteponer directorios a esta lista con la opción -I al compilar.

Operación de Inclusión

La directiva #include funciona dirigiendo al preprocesador de C para que escanee el archivo especificado como entrada antes de continuar con el resto del archivo fuente actual. La salida del preprocesador contiene la salida ya generada, seguida de la salida resultante del archivo incluido, seguida de la salida que proviene del texto después de la directiva #include. Por ejemplo, si tiene un archivo de cabecera header.h como sigue:

char *test (void);

y un programa principal llamado program.c que usa el archivo de cabecera, así:

int x;
#include "header.h"
int main (void) {
    puts (test ());
}

el compilador verá el mismo flujo de tokens que si program.c leyera:

int x;
char *test (void);
int main (void) {
    puts (test ());
}

Cabeceras de Inclusión Única

Si un archivo de cabecera se incluye dos veces, el compilador procesará su contenido dos veces y dará error. La forma estándar de evitar esto es encerrar todo el contenido real del archivo en una condicional, así:

#ifndef ARCHIVO_CABECERA
#define ARCHIVO_CABECERA
/* todo el contenido del archivo de cabecera */
#endif

Esta construcción se conoce comúnmente como envoltorio #ifndef. Cuando la cabecera se incluye de nuevo, la condicional será falsa, porque ARCHIVO_CABECERA está definido. El preprocesador saltará todo el contenido del archivo y el compilador no lo verá dos veces.

Inclusiones Calculadas

A veces es necesario seleccionar uno de varios archivos de cabecera diferentes para incluirlos en el programa. Por ejemplo, podrían especificar parámetros de configuración para diferentes sistemas operativos. Podría hacerlo con una serie de condicionales como sigue:

#if SISTEMA_1
# include "sistema_1.h"
#elif SISTEMA_2
# include "sistema_2.h"
#elif SISTEMA_3
...
#endif

Pero a medida que crece, se vuelve tedioso. En su lugar, el preprocesador ofrece la capacidad de usar un macro para el nombre de la cabecera. Esto se llama inclusión calculada. En lugar de escribir el nombre de la cabecera como argumento directo de #include, simplemente pone un nombre de macro allí:

#define SISTEMA_H "sistema_1.h"
...
#include SISTEMA_H

SISTEMA_H se expandirá, y el preprocesador buscará sistema_1.h como si el #include se hubiera escrito originalmente de esa manera. SISTEMA_H podría definirse en su Makefile con una opción -D.