Replacing text macros

El preprocesador admite el reemplazo de macros de texto y el reemplazo de macros de texto similares a funciones.

Sintaxis

Explicación

#define directivas

Las #define directivas definen el identifier como una macro, es decir, instruyen al compilador para reemplazar todas las ocurrencias sucesivas de identifier con replacement-list , que puede ser procesado opcionalmente de manera adicional. Si el identificador ya está definido como cualquier tipo de macro, el programa está mal formado a menos que las definiciones sean idénticas.

Macros similares a objetos

Las macros de tipo objeto reemplazan cada aparición de un identificador definido con una lista-de-reemplazo . La versión (1) de la directiva #define se comporta exactamente de esta manera.

Macros similares a funciones

Las macros similares a funciones reemplazan cada aparición de un identificador definido con una lista-de-reemplazo , tomando adicionalmente un número de argumentos, que luego reemplazan las apariciones correspondientes de cualquiera de los parámetros en la lista-de-reemplazo .

La sintaxis de una invocación de macro similar a una función es similar a la sintaxis de una llamada a función: cada instancia del nombre de la macro seguida de un ( como el siguiente token de preprocesamiento introduce la secuencia de tokens que es reemplazada por la lista de reemplazo. La secuencia termina con el token ) coincidente, omitiendo los pares coincidentes de paréntesis izquierdo y derecho intermedios.

El número de argumentos debe ser el mismo que el número de argumentos en la definición de la macro ( parameters ) o el programa está mal formado. Si el identificador no está en notación funcional, es decir, no tiene paréntesis después de sí mismo, no se reemplaza en absoluto.

La versión (2) de la directiva #define define una macro simple similar a una función.

La versión (3) de la directiva #define define una macro similar a una función con número variable de argumentos. Los argumentos adicionales pueden accederse usando el identificador __VA_ARGS__ , que luego es reemplazado con los argumentos proporcionados al identificador a ser reemplazado.

La versión (4) de la directiva #define define una macro similar a una función con número variable de argumentos, pero sin argumentos regulares. Los argumentos solo pueden accederse con el identificador __VA_ARGS__ , que luego es reemplazado con los argumentos proporcionados al identificador a ser reemplazado.

#define F(...) f(0 __VA_OPT__(,) __VA_ARGS__)
F(a, b, c) // replaced by f(0, a, b, c)
F()        // replaced by f(0)
#define G(X, ...) f(0, X __VA_OPT__(,) __VA_ARGS__)
G(a, b, c) // replaced by f(0, a, b, c)
G(a, )     // replaced by f(0, a)
G(a)       // replaced by f(0, a)
#define SDEF(sname, ...) S sname __VA_OPT__(= { __VA_ARGS__ })
SDEF(foo);       // replaced by S foo;
SDEF(bar, 1, 2); // replaced by S bar = { 1, 2 };

Nota: si un argumento de una macro similar a una función incluye comas que no están protegidas por pares coincidentes de paréntesis izquierdos y derechos (como macro ( array [ x = y, x + 1 ] ) o atomic_store ( p, ( struct S ) { a, b } ) ; ), la coma se interpreta como separador de argumentos de macro, causando un fallo de compilación debido a discrepancia en el número de argumentos.

# y ## operadores

En las macros similares a funciones, un operador # antes de un identificador en la replacement-list procesa el identificador mediante reemplazo de parámetros y encierra el resultado entre comillas, creando efectivamente un literal de cadena. Además, el preprocesador añade barras invertidas para escapar las comillas que rodean los literales de cadena incrustados, si los hay, y duplica las barras invertidas dentro de la cadena según sea necesario. Se eliminan todos los espacios en blanco iniciales y finales, y cualquier secuencia de espacios en blanco en medio del texto (pero no dentro de literales de cadena incrustados) se reduce a un solo espacio. Esta operación se denomina "stringification". Si el resultado de la stringification no es un literal de cadena válido, el comportamiento es indefinido.

#define showlist(...) puts(#__VA_ARGS__)
showlist();            // expands to puts("")
showlist(1, "x", int); // expands to puts("1, \"x\", int")

Un operador ## entre dos identificadores sucesivos en la replacement-list ejecuta el reemplazo de parámetros en los dos identificadores y luego concatena el resultado. Esta operación se denomina "concatenación" o "token pasting". Solo los tokens que forman un token válido juntos pueden pegarse: identificadores que forman un identificador más largo, dígitos que forman un número, u operadores + y = que forman un += . No se puede crear un comentario pegando / y * porque los comentarios se eliminan del texto antes de considerar la sustitución de macros. Si el resultado de la concatenación no es un token válido, el comportamiento es indefinido.

Nota: Algunos compiladores ofrecen una extensión que permite que ## aparezca después de una coma y antes de __VA_ARGS__ , en cuyo caso el ## no hace nada cuando __VA_ARGS__ no está vacío, pero elimina la coma cuando __VA_ARGS__ está vacío: esto hace posible definir macros como fprintf ( stderr , format, ##__VA_ARGS__) .

El orden de evaluación de los operadores # y ## no está especificado.

#undef directiva

La directiva #undef anula la definición del identificador , es decir, cancela la definición previa del identificador realizada por la directiva #define . Si el identificador no tiene una macro asociada, la directiva se ignora.

Macros predefinidos

Los siguientes nombres de macros están predefinidos en cualquier unidad de traducción:

Los siguientes nombres de macros adicionales pueden estar predefinidos por una implementación:

Los valores de estas macros (excepto para __FILE__ y __LINE__ ) permanecen constantes a lo largo de la unidad de traducción. Los intentos de redefinir o anular estas macros resultan en comportamiento indefinido.

Ejemplo

#include <stdio.h>
// make function factory and use it
#define FUNCTION(name, a) int fun_##name(int x) { return (a) * x; }
FUNCTION(quadruple, 4)
FUNCTION(double, 2)
#undef FUNCTION
#define FUNCTION 34
#define OUTPUT(a) puts( #a )
int main(void)
{
    printf("quadruple(13): %d\n", fun_quadruple(13));
    printf("double(21): %d\n", fun_double(21));
    printf("%d\n", FUNCTION);
    OUTPUT(billion); // note the lack of quotes
}

quadruple(13): 52
double(21): 42
34
billion

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C publicados anteriormente.

Referencias

Véase también