Macros con parámetros: Precedencia, stringification y token pasting

El preprocesador es el motor de sustitución de texto que opera antes de la compilación real. Cuando defines macros con parámetros, estás creando plantillas de código que el preprocesador expandirá literalmente en cada lugar donde se utilicen. Esto es fundamental en metaprogramación, como para generar nombres de variables de forma dinámica o para convertir nombres de variables en cadenas de texto para depuración, o bien para definir constantes que operan sin la sobrecarga de una llamada a función (aunque para lógica compleja, static inline es la norma moderna). Sin embargo, si no eres extremadamente cuidadoso, el compilador interpretará los tokens de forma errónea debido a la precedencia de los operadores, o podrías sufrir efectos secundarios inesperados si un argumento con incrementos se evalúa más de una vez. Si intentas concatenar tokens con el operador ##, podrías encontrarte con que las macros no se expanden como esperas si no implementas una capa de indirección.

#include <stdio.h>

/* 1. Precedencia y seguridad: El uso de paréntesis es obligatorio */
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define SQUARE_UNSAFE(x) x * x
#define SQUARE_SAFE(x) ((x) * (x))

/* 2. Stringification: El operador '#' convierte el argumento en un string literal */
#define DEBUG_VAR(x) printf("Valor de %s = %d\n", #x, x)

/* 3. Token Pasting: El operador '##' concatena dos tokens */
/* Para que los argumentos se expandan antes de concatenarse, 
   necesitamos una capa de indirección (indirection). */
#define CONCAT_INNER(a, b) a##b
#define CONCAT(a, b) CONCAT_INNER(a, b)

/* Generación de un getter simple mediante concatenación */
#define GETTER(type, name) type name##_get = name

int main(void) {
    int base_value = 42;
    int incremented_val = 0;

    /* Verificación de precedencia en MAX */
    /* Si MAX no tuviera paréntesis, (5 + 1) > (2 * 3) se evaluaría mal */
    int res_max = MAX(5 + 1, 2 * 3);
    printf("MAX(5+1, 2*3) = %d\n", res_max);

    /* Verificación de efectos secundarios (Double Evaluation) */
    /* SQUARE_SAFE es seguro, pero SQUARE_UNSAFE con incrementos es peligroso */
    int i = 5;
    int res_sq = SQUARE_SAFE(i++); 
    printf("SQUARE_SAFE(i++) -> res: %d, i: %d\n", res_sq, i);
    
    // Nota: i++ se evalúa una sola vez en SQUARE_SAFE gracias a los paréntesis.
    // En SQUARE_UNSAFE(i++), i se incrementaría dos veces.

    /* Verificación de Stringification */
    DEBUG_VAR(base_value);

    /* Verificación de Token Pasting y la capa de expansión */
    #define SUFFIX _val
    // Si usáramos CONCAT_INNER(base, SUFFIX), obtendríamos "baseSUFFIX"
    // Al usar CONCAT, el preprocesador expande SUFFIX primero.
    CONCAT(base_value, SUFFIX); 
    
    // Como la macro anterior no es una declaración válida de variable por sí sola,
    // vamos a usar el concepto para declarar una variable real.
    int var_test = 100;
    #define VAR_NAME var_test
    
    // Creamos una variable llamada 'var_test_val' usando la indirección
    // para asegurar que VAR_NAME se expande antes de concatenar.
    CONCAT_INNER(var_test, SUFFIX); // Esto fallaría si intentamos usar macros

    // Ejemplo funcional de concatenación de tokens para nombres
    int sensor_data = 255;
    #define PREFIX sensor_data
    // Intentar CONCAT(PREFIX, SUFFIX) resultará en sensor_data_val
    // porque CONCAT expande los argumentos antes de pasarlos a CONCAT_INNER.
    int sensor_data_val = 0; 
    // Usamos el resultado de la expansión de forma manual para el ejemplo:
    #define ACTUAL_VAL_NAME CONCAT(sensor_data, SUFFIX)
    // El compilador verá: sensor_data_val si el preprocesador lo resuelve.
    // Pero en C estándar, para que funcione en una declaración, 
    // el token resultante debe ser un identificador válido.
    
    printf("Valor concatenado (conceptual): %d\n", sensor_data);

    return 0;
}

Desglose del código

• Precedencia en MAX: Al definir MAX(a, b) as ((a) > (b) ? (a) : (b)), protegemos la evaluación. Si pasamos 5 + 1, la macro se expande a ((5 + 1) > (b) .... Sin los paréntesis en (a), la expresión 5 + 1 > b podría colisionar con otros operadores de mayor prioridad en expresiones complejas.
• Efectos secundarios: En SQUARE_SAFE(x), el paréntesis rodea a (x), lo que significa que si pasas i++, el compilador trata el resultado de i++ como un único valor antes de multiplicarlo. En la versión insegura, x * x se convierte en i++ * i++, lo que incrementa i dos veces, un comportamiento que depende de la implementación pero que es altamente problemático.
• DEBUG_VAR y #: El operador #x le dice al preprocesador: “toma el token que entró por el parámetro x y conviértelo en un literal de cadena”. Esto es lo que permite que DEBUG_VAR(base_value) produzca el string "base_value".
• La indirección en CONCAT: Este es un detalle avanzado del preprocesador. Si usas ## directamente en una macro que recibe otro parámetro macro a##b, y b es una macro, el preprocesador concatena el nombre de la macro b en lugar de su valor. Al llamar a CONCAT(a, b) que a su vez llama a CONCAT_INNER(a, b), el preprocesador primero expande b (si es una macro) y luego pasa el resultado ya expandido a CONCAT_INNER, permitiendo la concatenación del valor real.

El error frecuente

Un error clásico es intentar usar una macro con efectos secundarios dentro de una macro que evalúa el argumento más de una vez.

#define ITERATE_TWICE(x) (x + x)

int main(void) {
    int i = 10;
    int res = ITERATE_TWICE(i++); 
    // Esperado: (10 + 10) = 20, i = 11
    // Real: (10 + 11) = 21, i = 12 (o incluso undefined behavior)
}

Este error es extremadamente difícil de detectar en sistemas complejos. Si usas herramientas como AddressSanitizer o Valgrind, no detectarán esto necesariamente porque no es un error de memoria, sino un error de lógica derivado del comportamiento del preprocesador. La regla de oro es: si tu macro usa el argumento más de una vez, no permitas que el argumento sea una expresión con efectos secundarios.

N° 41