Compilación condicional en C: #ifdef, #ifndef, #if y -D

La compilación condicional permite que un solo archivo fuente se convierta en varios programas distintos. El preprocesador decide, antes de que corra el compilador, qué bloques de texto sobreviven, así que el código dentro de una rama que no se cumple no solo se salta en tiempo de ejecución: se elimina. Nunca llega a analizarse, así que no aporta nada al ejecutable e incluso puede contener construcciones que el compilador actual rechazaría.

Esa es la diferencia con un if ordinario. Ambos eligen entre caminos; solo uno de ellos elige antes de que el programa exista.

#ifdef e #ifndef

La pregunta más simple es si una macro está definida:

#include <stdio.h>

#define DEBUG

int main(void) {
#ifdef DEBUG
    printf("[debug] entrando a main\n");
#endif

    int total = 0;
    for (int i = 1; i <= 5; i++) {
        total += i;
#ifdef DEBUG
        printf("[debug] i=%d total=%d\n", i, total);
#endif
    }

    printf("Total: %d\n", total);
    return 0;
}

Elimina la línea #define DEBUG y cada impresión de depuración desaparece de la compilación: no desactivada, desaparecida. Ejecútalo una vez tal como está, luego quita esa línea y ejecútalo de nuevo.

#ifndef es la negación: conserva el bloque solo si la macro no está definida. Su uso más común es el guard de inclusión que se cubre en archivos de cabecera, y también es la forma de dar un valor por defecto que quien llama pueda sobrescribir:

#include <stdio.h>

/* Una compilación puede sobrescribir esto con -DBUFFER_SIZE=512 */
#ifndef BUFFER_SIZE
#define BUFFER_SIZE 128
#endif

int main(void) {
    char buffer[BUFFER_SIZE];
    printf("El buffer guarda %zu bytes\n", sizeof(buffer));
    return 0;
}

Todo #ifdef e #ifndef debe cerrarse con #endif. Anotar el cierre en archivos largos — #endif /* DEBUG */ — ahorra tiempo real más adelante.

#if, #elif, #else

#if toma una expresión entera constante y conserva el bloque cuando es distinta de cero. Eso hace posibles las comparaciones de versión y de nivel:

#include <stdio.h>

#define LOG_LEVEL 2   /* 0 = silencioso, 1 = errores, 2 = info, 3 = detallado */

int main(void) {
#if LOG_LEVEL >= 3
    printf("detallado: cada detalle\n");
#endif

#if LOG_LEVEL >= 2
    printf("info: iniciando\n");
#endif

#if LOG_LEVEL >= 1
    printf("el reporte de errores esta activo\n");
#elif LOG_LEVEL == 0
    printf("(compilacion silenciosa)\n");
#endif

    return 0;
}

Cambia LOG_LEVEL a 0 o a 3 y vuelve a ejecutar para ver cómo el programa mismo cambia de forma.

La expresión la evalúa el preprocesador, lo que significa que solo puede usar constantes enteras, operadores aritméticos y de comparación, y macros que se expandan a eso. No puede ver sizeof, valores de enum, variables ni nada que necesite al compilador. Una macro no definida dentro de un #if se evalúa como 0 en lugar de ser un error, lo que resulta conveniente y ocasionalmente sorprendente:

#if FEATURE_X        /* FEATURE_X nunca se define en ningún lado -> 0 -> el bloque se descarta */

defined(NOMBRE) convierte la pregunta de #ifdef en algo utilizable dentro de un #if, así que puedes combinar pruebas:

#if defined(DEBUG) && !defined(NDEBUG)
    /* build de depuración, y las aserciones están activas */
#endif

#if defined(LINUX) || defined(BSD)
    /* cualquiera de los dos sistemas tipo unix */
#endif

#if defined(X) e #ifdef X significan lo mismo; usa el primero cuando necesites &&, || o !.

Definir macros desde la línea de comandos

El verdadero poder de estos interruptores es que el código fuente no necesita cambiar en absoluto. gcc -D define una macro para toda la compilación:

gcc -DDEBUG programa.c -o programa        # DEBUG definido como 1
gcc -DLOG_LEVEL=3 programa.c -o programa  # valor específico
gcc -DDEBUG -DBUFFER_SIZE=512 a.c b.c -o app

-DNOMBRE por sí solo equivale a #define NOMBRE 1. -U NOMBRE quita una definición, lo que importa cuando una cabecera define algo que quieres apagar.

Así que el arreglo habitual es: el código fuente contiene valores por defecto protegidos con #ifndef, y el comando de construcción selecciona una configuración.

/* config.h */
#ifndef LOG_LEVEL
#define LOG_LEVEL 1        /* silencioso por defecto */
#endif

#ifndef MAX_CONNECTIONS
#define MAX_CONNECTIONS 64
#endif

# build de desarrollo
gcc -DDEBUG -DLOG_LEVEL=3 -Wall -Wextra -g src/*.c -o app-dev

# build de producción
gcc -DNDEBUG -O2 src/*.c -o app

NDEBUG está estandarizado: definirlo desactiva cada assert() del programa, porque <assert.h> está escrito él mismo con compilación condicional. Ese es el patrón en miniatura: una cabecera que compila a cosas distintas según lo que haya definido el build.

Interruptores de plataforma

Los compiladores predefinen macros que identifican el sistema de destino, así que un solo archivo fuente puede llamar a la API correcta en cada uno:

#if defined(_WIN32)
    #include <windows.h>
    #define CLEAR_SCREEN "cls"
#elif defined(__APPLE__)
    #include <unistd.h>
    #define CLEAR_SCREEN "clear"
#elif defined(__linux__)
    #include <unistd.h>
    #define CLEAR_SCREEN "clear"
#else
    #error "Plataforma no soportada"
#endif

Las comunes: _WIN32 (definida tanto en Windows de 32 como de 64 bits), _WIN64, __linux__, __APPLE__, __unix__, __ANDROID__. La identidad del compilador tiene su propio conjunto — __GNUC__, __clang__, _MSC_VER — y la arquitectura también — __x86_64__, __aarch64__.

Una versión ejecutable que reporta sobre qué fue construido:

#include <stdio.h>

int main(void) {
#if defined(_WIN32)
    const char *os = "Windows";
#elif defined(__APPLE__)
    const char *os = "macOS";
#elif defined(__linux__)
    const char *os = "Linux";
#else
    const char *os = "otro sistema";
#endif

#if defined(__clang__)
    const char *cc = "clang";
#elif defined(__GNUC__)
    const char *cc = "GCC";
#else
    const char *cc = "un compilador no identificado";
#endif

    printf("Construido para %s con %s\n", os, cc);
    printf("Estandar de C: %ld\n", __STDC_VERSION__);
    return 0;
}

#error vale la pena conocerlo por sí solo: detiene la compilación con tu mensaje. Terminar una cadena de plataformas con #else / #error "Plataforma no soportada" convierte una compilación mal hecha y silenciosa en un fallo claro al principio del registro de construcción.

Para listar cada macro que tu compilador predefine:

gcc -dM -E - < /dev/null

Esa salida es la respuesta autoritativa a "qué puedo probar en esta máquina".

#if 0 para desactivar código

Comentar un bloque con /* ... */ falla en el momento en que el bloque contiene un comentario propio, porque los comentarios de C no se anidan: el primer */ dentro termina el comentario externo y todo lo que sigue se convierte en código suelto. #if 0 no tiene ese problema:

#if 0
    /* Toda esta región se elimina, comentarios incluidos. */
    legacy_init();
    int n = old_calculation(42);  /* incluso este comentario está bien */
    report(n);
#endif

Cámbialo a #if 1 para traer el código de vuelta. Los editores lo siguen resaltando como C, y puedes anidar un #if 0 dentro de otro #if.

Es una herramienta de depuración, no un sistema de almacenamiento. El código que vive en un #if 0 nunca se compila, así que se pudre en silencio: no va a compilar para cuando alguien mueva el interruptor. Úsalo mientras acotas un problema, luego borra el bloque y deja que el control de versiones lo recuerde.

Dónde sale mal la compilación condicional

Tres modos de fallo explican la mayor parte del dolor.

El código que nunca se compila nunca se verifica. Un error de tipeo dentro de una rama #ifdef inactiva es invisible hasta que alguien construye esa configuración: posiblemente meses después, posiblemente en CI sobre una plataforma que no tienes. Si un proyecto tiene ramas de plataforma interesantes, constrúyelas todas con regularidad.

Entrelazar #ifdef con el flujo de control se vuelve ilegible rápido. Este tipo de cosa es difícil de razonar:

if (ready) {
#ifdef FAST_PATH
    fast_send(buf);
} else {
#endif
    slow_send(buf);
}

Llaves abiertas en una rama y cerradas en otra son legales y horribles. Prefiere condicionales que envuelvan funciones completas, y selecciona entre ellas:

#ifdef FAST_PATH
static void send_data(const char *buf) { fast_send(buf); }
#else
static void send_data(const char *buf) { slow_send(buf); }
#endif

Un if en tiempo de ejecución suele ser mejor. Si ambas ramas compilarían en todas partes, un if (debug_enabled) ordinario mantiene los dos caminos con verificación de tipos, testeables y conmutables sin recompilar. Reserva el preprocesador para lo que solo él puede hacer: código que genuinamente no puede compilar en la otra plataforma.

Para el patrón que combina todo esto — una cabecera de valores por defecto, un -D por compilación y ramas de plataforma envueltas en guards de inclusión — mira archivos de cabecera; para #define en sí, macros.