macro variádica

La sintaxis de declaración es similar a la de las funciones variádicas : se utiliza una secuencia de tres puntos " ..." para indicar que se deben pasar uno o más argumentos. Durante la expansión de la macro, cada aparición del identificador especial __VA_ARGS__en la lista de reemplazo de macros se reemplaza por los argumentos pasados.

Además, los argumentos macro regulares pueden aparecer antes del ..., ^{[ 4 ]} pero los argumentos regulares no pueden aparecer después del ....

No se proporciona ningún medio para acceder a los argumentos individuales en la lista de argumentos variables, ni para averiguar cuántos se pasaron. Sin embargo, se pueden escribir macros para contar el número de argumentos que se han pasado. ^{[ 5 ]}

Tanto el estándar C99 como el C++11 requieren al menos un argumento, pero desde C++20 y C23 esta limitación se ha eliminado mediante la __VA_OPT__macro funcional. La __VA_OPT__macro se reemplaza por su argumento cuando hay argumentos presentes, y se omite en caso contrario. Sin embargo, los compiladores comunes también permiten pasar cero argumentos antes de esta adición. ^{[ 4 ] [ 6 ]}

Las reglas del preprocesador de C impiden que los nombres de las macros en el argumento __VA_OPT__se expandan recursivamente. Sin embargo, es posible sortear esta limitación hasta un número fijo arbitrario de expansiones recursivas. ^{[ 7 ]}

Varios compiladores admiten macros de argumentos variables al compilar código C y C++: GNU Compiler Collection 3.0, ^{[ 4 ]} Clang (todas las versiones), ^{[ 8 ]} Visual Studio 2005 , ^{[ 6 ]} C++Builder 2006 y Oracle Solaris Studio (anteriormente Sun Studio) Forte Developer 6 actualización 2 (versión C++ 5.3). ^{[ 9 ]} GCC también admite dichas macros al compilar Objective-C .

Se ha añadido soporte para que la __VA_OPT__macro admita cero argumentos en GNU Compiler Collection 8, ^{[ 10 ]} Clang 6, ^{[ 11 ]} y Visual Studio 2019 . ^{[ 12 ]}

Si se deseara una funciónprintf similar que tomara como argumentos el archivo y el número de línea desde el que se llama, se aplica la siguiente solución.dbgprintf()

Nuestra función implementada:

void debugPrint ( const char * archivo , int línea , const char * fmt , ...);

Debido a las limitaciones del soporte de macros variádicas en C++11, la siguiente solución sencilla puede fallar y, por lo tanto, debe evitarse:

#define dbgprintf(cformat, ...) debugPrint(__FILE__, __LINE__, cformat, __VA_ARGS__)

La razón es que

dbgprintf ( "Hola" )

se expande a

debugPrint ( __FILE__ , __LINE__ , "Hola" , )

donde la coma antes de la llave de cierre dará como resultado un error de sintaxis.

GNU C++ admite una extensión no portable que resuelve este problema:

#define dbgprintf(cformat, ...) debugPrint(__FILE__, __LINE__, cformat, ##__VA_ARGS__)

C++20 admite la siguiente sintaxis.

#define dbgprintf(cformat, ...) debugPrint(__FILE__, __LINE__, cformat __VA_OPT__(,) __VA_ARGS__)

Al usar la cformatcadena como parte de los argumentos variables, podemos sortear las incompatibilidades mencionadas anteriormente. Esto es complejo, pero portable.

#define dbgprintf(...) debugPrint(__FILE__, __LINE__, __VA_ARGS__)

dbgprintf()podría entonces llamarse como

dbgprintf ( "Hola, mundo" );

que se expande a

debugPrint ( __FILE__ , __LINE__ , "Hola, mundo" );

Otro ejemplo es:

dbgprintf ( "%d + %d = %d" , 2 , 2 , 5 );

que se expande a

debugPrint ( __FILE__ , __LINE__ , "%d + %d = %d" , 2 , 2 , 5 );

Sin macros variádicas, no es posible escribir printfdirectamente funciones envolventes. La solución habitual consiste en utilizar la funcionalidad stdargs de C/C++ y realizar la llamada a la función vprintfen su lugar.

Existe un problema de portabilidad al generar una coma final con argumentos vacíos para macros variádicas en C99 . Algunos compiladores (por ejemplo, Visual Studio cuando no utiliza el nuevo preprocesador conforme al estándar ^{[ 6 ]} ) eliminarán silenciosamente la coma final. Otros compiladores (por ejemplo, GCC ^{[ 4 ]} ) admiten colocar ##delante de __VA_ARGS__.

#define MYLOG(FormatLiteral, ...) fprintf(stderr, "%s(%u): " FormatLiteral "\n", __FILE__, __LINE__, __VA_ARGS__)

La siguiente aplicación funciona

MYLOG ( "Demasiados globos %u" , 42 );

que se expande a

fprintf ( stderr , "%s(%u): " "Demasiados globos %u" " \n " , __FILE__ , __LINE__ , 42 );

lo cual es equivalente a

fprintf ( stderr , "%s(%u): Demasiados globos %u \n " , __FILE__ , __LINE__ , 42 );

Pero fíjense en esta aplicación:

MYLOG ( "¡Atención!" );

que se expande a

fprintf ( stderr , "%s(%u): " "¡Atención!" " \n " , __FILE__ , __LINE__ , );

lo que genera un error de sintaxis con GCC.

GCC admite la siguiente extensión (no portátil):

#define MYLOG(FormatLiteral, ...) fprintf(stderr, "%s(%u): " FormatLiteral "\n", __FILE__, __LINE__, ##__VA_ARGS__)

que elimina la coma final cuando __VA_ARGS__está vacío.

C23 resuelve este problema introduciendo __VA_OPT__algo similar a C++. ^{[ 3 ]}

Antes de la existencia de argumentos variables en C99, era bastante común usar paréntesis doblemente anidados para aprovechar el número variable de argumentos que se podían proporcionar a la printf()función:

#define dbgprintf(x) debugPrint x

dbgprintf()podría entonces llamarse como:

dbgprintf (( "Hola, mundo %d" , 27 ));

que se expande a:

debugPrint ( "Hola, mundo %d" , 27 );