Replacing text macros

El preprocesador soporta macros para reemplazo de texto y macros para reemplazo de texto similares a funciones.

[editar] Sintaxis

[editar] Explicación

[editar] Directivas #define

Las directivas #define definen el identificador como una macro, es decir, ordenan al compilador que reemplace todas las sucesivas ocurrencias del identificador con la lista-de-sustitución, que opcionalmente pueden ser procesadas adicionalmente. Si el identificador ya está definido como cualquier tipo de macro, el programa está mal formado a menos que las definiciones sean idénticas.

[editar] Macros de tipo objeto

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

[editar] Macros de tipo función

Las macros de función sustituyen cada ocurrencia de un identificador definido en la lista-de-sustitución, tomando adicionalmente un número de argumentos, que luego reemplazan las ocurrencias correspondientes de cualquiera de los parámetros de la lista-de-sustitución.

La sintaxis de una macro de función es similar a la sintaxis de una llamada de función: cada instancia del nombre de la macro seguida de un token (ya que el siguiente token de preprocesamiento introduce la secuencia de tokens que es reemplazada por la lista de reemplazos. La secuencia termina con la coincidencia), omitiendo los pares de paréntesis de izquierda y derecha.

El número de argumentos debe ser el mismo que el de la definición de la macro (parámetros) 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 sustituye 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 un número variable de argumentos. Se puede acceder a los argumentos adicionales utilizando el identificador __VA_ARGS__, que luego se sustituye por argumentos, suministrados con el identificador que se va a sustituir.

La versión (4) de la directiva #define define una macro similar a una función con un número variable de argumentos, pero sin argumentos regulares. Sólo se puede acceder a los argumentos con el identificador __VA_ARGS__, que luego se sustituye por argumentos, suministrados con el identificador a sustituir.supplied with identifier to be replaced.

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 izquierdo y derecho (como macro(array[x = y, x + 1]) o atomic_store (p, (struct S){ a, b });), la coma se interpreta como separador de argumentos de la macro, causando un fallo en la compilación debido al desajuste en el recuento de argumentos.

[editar] Los operadores # y ##

En macros de tipo función, un operador # antes de un identificador en la lista de sustitución ejecuta el identificador a través de la sustitución de parámetros y encierra el resultado entre comillas, creando efectivamente una cadena literal. Además, el preprocesador añade barras invertidas para escapar de las comillas que rodean a los literales de las cadenas incrustadas, si las hubiera, 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 el centro del texto (pero no dentro de los literales de cadena incrustados) se comprime en un solo espacio. Esta operación se denomina "encadenamiento". Si el resultado del encadenamiento no es un literal de encadenamiento válido, el comportamiento sera 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 cualesquiera en la lista-de-sustitución ejecuta la substitution de parámetros en los dos identificadores y luego concatena el resultado. Esta operación se denomina "concatenación" o "pegado de tokens". Sólo se pueden pegar los tokens que forman un token válido juntos: 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 sera 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 permite definir macros como fprintf (stderr, format, ##__VA_ARGS__).

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

[editar] La directiva #undef

La directiva #undef desdefine el identificador, es decir, cancela la definición anterior del identificador mediante la directiva #define. Si el identificador no tiene una macro asociada, la directiva sera ignorada.

[editar] Predefined macros

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

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

Los valores de estas macros (excepto __FILE__ y __LINE__) permanecen constantes en toda la unidad de traducción. Los intentos de redefinir o desdefinir estas macros resultan en un comportamiento indefinido.

[editar] 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(million);               //note the lack of quotes
}

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

[editar] Referencias