macros variadic con cero argumentos

Question

estoy trabajando en una macro llamada,

#define CALL(f,...) FN(f)->call((ref(new LinkedList()), __VA_ARGS__)) 

que cuando se llama,

CALL(print,2,3,4,5); 

añade 2 3 4 5 de la lista enlazada (, está sobrecargado para hacerlo) y las llamadas se imprimen, lo que espera una lista vinculada que funcione como se espera, aunque haya algunas llamadas que no requieren argumentos,

CALL(HeapSize); 

Todavía toma una lista vinculada pero una vacía, arriba no funciona, ¿estoy tratando de encontrar una macro que funcione con cualquiera de los dos estilos?

EDIT: Digging throug docs gcc he encontrado que la adición de ## antes de VA_ARGS elimina el, cuando no hay argumentos, pero con eso no puedo macros nido,

CALL(print,CALL(HeadSize)); 

esto hace que la llamada no se define de error Cómo siempre, si separo las llamadas funciona

Answer 1

En cuanto a la pregunta actualizada, mediante el uso de la macro auxiliar VA_ARGS como , los argumentos se ampliarán según lo esperado.

#define VA_ARGS(...) , ##__VA_ARGS__ 
#define CALL(f,...) FN(f)->call((ref(new LinkedList()) VA_ARGS(__VA_ARGS__))) 

Answer 2

Desafortunadamente esto no se puede hacer. Tendrá que definir una macro por separado para hacer esta llamada.

Como se termina con argumentos no válidos al VA_ARGS se sustituye con nada se termina con una flota ,

#define CALL0(f) FN(f)->call((ref(new LinkedList()))) 

Answer 3

Si está utilizando GCC, que tiene una extensión de tragar hasta la coma que precede a la __VA_ARGS__. Ver: http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html.

Answer 4

Si está utilizando gcc/g ++ hay una manera:

#define CALL(f,...) FN(f)->call((ref(new LinkedList()), ## __VA_ARGS__)) 

Desde el fine manual:

[...] si los argumentos variables se omiten o se vacía, el ` ## 'hace que el preprocesador elimine la coma que tiene delante.

Así gcc tiene una extensión/pirateo específicamente para el problema al que se enfrenta.

Answer 5

Simplemente haga f parte de ..., y use una macro separada para extraer el primer argumento donde necesite f.

Answer 6

Un tema común en estas respuestas es que necesitamos un hack específico de GCC. Una forma es usar token-paste ##__VAR_ARGS__, pero los argumentos pegados no se expanden en macro, lo que significa que las macros no se pueden anidar.Pero si usted va a hacer algo GCC específica de todos modos, ¿por qué no usar la antigua extensión de GCC:

#define VARARG_FOO(ZeroOrMoreArgs...) \ 
    printf("VARARG_FOO: " ZeroOrMoreArgs) 

ZeroOrMoreArgs simplemente se sustituye por todos los argumentos (si los hay), comas y todo. Esto incluye la expansión de macro recursiva.

• entonces VARARG_FOO() expande a printf("VARARG_FOO: ")
• y VARARG_FOO("I iz %d", 42) expande a printf("VARARGFOO: " "I iz %d", 42)

Finalmente

#define NEST_ME "I tawt I taw a puddy tat" 
VARARG_FOO("The evil one says %s", NEST_ME); 

se expandirá a

printf("VARARG_FOO: " "The evil one says %s", "I tawt I taw a puddy tat"); 

Pros:

• puede anidar macro invocaciones, mientras que tienen cero o más aguments.

Contras:

• El ##__VA_ARGS__ hackear podría ser inofensivo en los programas en C estándar en el caso en el que siempre tienen al menos una coma. (No he pensado si esto es cierto o no).
• Según @ScootMoonen, el truco ##__VA_ARGS__ es una extensión no documentada de MSVC.