Macros variadiques avec zéro argument

Je suis en train de travailler sur un appel de macro,

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

qui, lorsqu'il est appelé,

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

ajoute 2 3 4 5 de la liste chaînée (, est surchargé de le faire) et les appels d'impression qui s'attend à une liste, qui fonctionne comme prévu comment jamais, il y a des appels qui ne nécessitent pas d'arguments,

CALL(HeapSize);

Il faut toujours une liste, mais un vide, au-dessus ne fonctionne pas, je suis en train d'essayer de trouver une macro qui woud de travailler avec style?

EDIT: Creuser par le gcc docs que j'ai trouvé que l'ajout de ## avant VA_ARGS supprime l' , quand il n'y a pas d'arguments, mais avec qui je ne peux pas imbriquer des macros,

CALL(print,CALL(HeadSize));

cela provoque APPEL non défini erreur comment jamais, si j'ai séparé les appels il fonctionne

source d'informationauteur Hamza Yerlikaya

  1. 17

    Que pour la mise à jour de la question, par l'utilisation de l'auxiliaire de macro VA_ARGS comme
    la suite, les arguments seront élargis comme prévu.

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

    Si vous utilisez gcc/g++ il y a un moyen:

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

    De la beaux-manuel:

    [...] si la variable d'arguments sont omis ou vide, ` # # ' opérateur provoque le préprocesseur pour supprimer la virgule avant.

    Donc gcc a une extension/hack spécifiquement pour le problème auquel vous êtes confronté.

  3. 4

    Si vous utilisez GCC, il a une extension pour avaler la virgule précédant la __VA_ARGS__. Voir: http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html.

  4. 1

    Un thème commun à ces réponses, c'est que nous avons besoin d'un GCC spécifiques hack. Une façon est d'utiliser le jeton-coller ##__VAR_ARGS__mais collé arguments ne sont pas de macro élargi, ce qui signifie que les macros ne peuvent pas être imbriqués. Mais si vous allez faire quelque chose de GCC spécifique de toute façon, alors pourquoi ne pas utiliser l'ancienne GCC extension: 

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

    ZeroOrMoreArgs est tout simplement remplacé par tous les arguments (le cas échéant), les virgules et tout. Cela comprend récursive macro extension.

    • puis VARARG_FOO() étend à printf("VARARG_FOO: ")
    • et VARARG_FOO("I iz %d", 42) étend à printf("VARARGFOO: " "I iz %d", 42)

    Enfin 

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

    étendra à

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

    Pour:

    • Vous pouvez imbriquer des macro invocations, tout en ayant zéro ou plus d'aguments.

    Contre:

    • La ##__VA_ARGS__ hack pourrait être inoffensif dans la norme des programmes en C dans le cas où ils ont toujours au moins une virgule. (Je n'ai pas pensé que cela soit vrai ou pas).
    • Selon @ScootMoonen la ##__VA_ARGS__ hack est un sans-papiers extension de MSVC.
  5. 0

    Malheureusement, cela ne peut être fait. Vous aurez besoin de définir une macro distincts de faire cet appel.

    Que vous vous retrouvez avec des arguments non valides lorsque VA_ARGS est remplacé par rien, vous vous retrouvez avec un flottant ,

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

    Simplement faire f partie de la ...et utiliser une macro pour extraire le premier argument où vous en avez besoin f.