Standard alternative de GCC ##__VA_ARGS__ tromper?

Il y a un argument de comptage astuce que vous pouvez utiliser.

Ici est un standard conforme façon de mettre en œuvre la deuxième BAR() exemple dans jwd la question:

#include <stdio.h>

#define BAR(...) printf(FIRST(__VA_ARGS__) "\n" REST(__VA_ARGS__))

/* expands to the first argument */
#define FIRST(...) FIRST_HELPER(__VA_ARGS__, throwaway)
#define FIRST_HELPER(first, ...) first

/*
 * if there's only one argument, expands to nothing.  if there is more
 * than one argument, expands to a comma followed by everything but
 * the first argument.  only supports up to 9 arguments but can be
 * trivially expanded.
 */
#define REST(...) REST_HELPER(NUM(__VA_ARGS__), __VA_ARGS__)
#define REST_HELPER(qty, ...) REST_HELPER2(qty, __VA_ARGS__)
#define REST_HELPER2(qty, ...) REST_HELPER_##qty(__VA_ARGS__)
#define REST_HELPER_ONE(first)
#define REST_HELPER_TWOORMORE(first, ...) , __VA_ARGS__
#define NUM(...) \
    SELECT_10TH(__VA_ARGS__, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
#define SELECT_10TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, ...) a10

int
main(int argc, char *argv[])
{
    BAR("first test");
    BAR("second test: %s", "a string");
    return 0;
}

Cette astuce est utilisée pour:

• compter le nombre d'arguments
• développer différemment selon le nombre d'arguments
• ajouter à __VA_ARGS__

Explication

La stratégie est de séparer __VA_ARGS__ dans le premier argument et le reste (le cas échéant). Cela permet d'insérer des trucs après le premier argument, mais avant la deuxième (si présent).

FIRST()

Cette macro simplement se développe pour le premier argument, en rejetant le reste.

La mise en œuvre est simple. Le throwaway argument assure que FIRST_HELPER() reçoit deux arguments, ce qui est nécessaire parce que le ... besoin d'au moins une. Avec un argument, il se développe comme suit:

1. FIRST(firstarg)
2. FIRST_HELPER(firstarg, throwaway)
3. firstarg

Avec deux ou plus de deux, elle se développe comme suit:

1. FIRST(firstarg, secondarg, thirdarg)
2. FIRST_HELPER(firstarg, secondarg, thirdarg, throwaway)
3. firstarg

REST()

Cette macro s'étend à tout, mais le premier argument (y compris la virgule après le premier argument, si il n'y a plus d'un argument).

La mise en œuvre de cette macro est beaucoup plus compliqué. La stratégie générale est de compter le nombre d'arguments (un ou plus d'un) et puis développez soit REST_HELPER_ONE() (si un seul argument donné) ou REST_HELPER_TWOORMORE() (si deux ou plus de deux arguments). REST_HELPER_ONE() simplement étend à rien, il n'y a pas d'arguments après la première, de sorte que les arguments restants est l'ensemble vide. REST_HELPER_TWOORMORE() est aussi simple, il se développe à une virgule suivie par tout, sauf le premier argument.

Les arguments sont comptées à l'aide de la NUM() macro. Cette macro s'étend à ONE si un seul argument est fourni, TWOORMORE si, entre deux et neuf arguments sont donnés, et des pauses si 10 ou plusieurs arguments sont donnés (parce qu'il se développe à la 10e argument).

La NUM() macro utilise la SELECT_10TH() macro pour déterminer le nombre d'arguments. Comme son nom l'indique, SELECT_10TH() simplement se développe pour sa 10e argument. En raison de l'ellipse, SELECT_10TH() doit être transmis au moins 11 des arguments (la norme dit qu'il doit y avoir au moins un argument pour les points de suspension). C'est pourquoi NUM() passe throwaway comme le dernier argument (sans elle, passant un argument pour NUM() seraient seuls 10 arguments passés à SELECT_10TH(), qui constituerait une violation de la norme).

Sélection de REST_HELPER_ONE() ou REST_HELPER_TWOORMORE() est fait par concaténation de REST_HELPER_ avec l'expansion de NUM(__VA_ARGS__) dans REST_HELPER2(). Notez que le but de REST_HELPER() est de s'assurer que NUM(__VA_ARGS__) est complètement développé avant d'être concaténé avec REST_HELPER_.

Expansion avec un argument qui va comme suit:

1. REST(firstarg)
2. REST_HELPER(NUM(firstarg), firstarg)
3. REST_HELPER2(SELECT_10TH(firstarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg)
4. REST_HELPER2(ONE, firstarg)
5. REST_HELPER_ONE(firstarg)
6. (vide)

Expansion avec deux arguments ou plus va comme suit:

1. REST(firstarg, secondarg, thirdarg)
2. REST_HELPER(NUM(firstarg, secondarg, thirdarg), firstarg, secondarg, thirdarg)
3. REST_HELPER2(SELECT_10TH(firstarg, secondarg, thirdarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg, secondarg, thirdarg)
4. REST_HELPER2(TWOORMORE, firstarg, secondarg, thirdarg)
5. REST_HELPER_TWOORMORE(firstarg, secondarg, thirdarg)
6. , secondarg, thirdarg

Il y a un moyen de gérer ce cas particulier en utilisant quelque chose comme Coup de pouce.Préprocesseur. Vous pouvez utiliser BOOST_PP_VARIADIC_SIZE pour vérifier la taille de la liste d'arguments, et puis conditionaly étendre à une autre macro. Le seul inconvénient c'est qu'il ne peut pas distinguer entre 0 et 1 argument, et la raison pour laquelle cela devient évident une fois que vous considérez les points suivants:

BOOST_PP_VARIADIC_SIZE()      //expands to 1
BOOST_PP_VARIADIC_SIZE(,)     //expands to 2
BOOST_PP_VARIADIC_SIZE(,,)    //expands to 3
BOOST_PP_VARIADIC_SIZE(a)     //expands to 1
BOOST_PP_VARIADIC_SIZE(a,)    //expands to 2
BOOST_PP_VARIADIC_SIZE(,b)    //expands to 2
BOOST_PP_VARIADIC_SIZE(a,b)   //expands to 2
BOOST_PP_VARIADIC_SIZE(a, ,c) //expands to 3

Le vide macro argument de la liste se compose en fait d'un argument qui se trouve être vide.

Dans ce cas, nous avons la chance depuis votre macro souhaitée a toujours au moins 1 argument, nous pouvons mettre en œuvre que les deux "surcharge" des macros:

#define BAR_0(fmt) printf(fmt "\n")
#define BAR_1(fmt, ...) printf(fmt "\n", __VA_ARGS__)

Et puis une autre macro pour basculer entre eux, tels que:

#define BAR(...) \
    BOOST_PP_CAT(BAR_, BOOST_PP_GREATER(
        BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1))(__VA_ARGS__) \
    /**/

ou

#define BAR(...) BOOST_PP_IIF( \
    BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1), \
        BAR_1, BAR_0)(__VA_ARGS__) \
    /**/

Celui qui vous est le plus lisible (je préfère la première car il vous donne une forme générale pour la surcharge des macros sur le nombre d'arguments).

Il est également possible de le faire avec une seule macro par l'accès et de la mutation de la variable d'arguments, mais c'est moins lisible, et est très spécifique à ce problème:

#define BAR(...) printf( \
    BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) "\n" \
    BOOST_PP_COMMA_IF( \
        BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1)) \
    BOOST_PP_ARRAY_ENUM(BOOST_PP_ARRAY_POP_FRONT( \
        BOOST_PP_VARIADIC_TO_ARRAY(__VA_ARGS__)))) \
    /**/

Aussi, pourquoi n'est-il pas BOOST_PP_ARRAY_ENUM_TRAILING? Il serait de rendre cette solution beaucoup moins horrible.

Edit: Bon, voici une BOOST_PP_ARRAY_ENUM_TRAILING, et une version qui l'utilise (c'est maintenant ma solution préférée):

#define BOOST_PP_ARRAY_ENUM_TRAILING(array) \
    BOOST_PP_COMMA_IF(BOOST_PP_ARRAY_SIZE(array)) BOOST_PP_ARRAY_ENUM(array) \
    /**/

#define BAR(...) printf( \
    BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) "\n" \
    BOOST_PP_ARRAY_ENUM_TRAILING(BOOST_PP_ARRAY_POP_FRONT( \
        BOOST_PP_VARIADIC_TO_ARRAY(__VA_ARGS__)))) \
    /**/

Très simple macro que j'utilise pour l'impression de débogage:

#define __DBG_INT(fmt, ...) printf(fmt "%s", __VA_ARGS__);
#define DBG(...) __DBG_INT(__VA_ARGS__, "\n")

int main() {
        DBG("No warning here");
        DBG("and we can add as many arguments as needed. %s", "nice!");
        return 0;
}

Peu importe le nombre d'arguments passés à DBG il n'y a pas c99 avertissement.

Le truc, c'est __DBG_INT l'ajout d'un mannequin param donc ... aura toujours au moins un argument et c99 est satisfait.

Dans votre situation (au moins 1 argument présent, jamais 0), vous pouvez définir BAR comme BAR(...), utilisez Jens Gustedt de l' HAS_COMMA(...) pour détecter une virgule et de la répartition à la BAR0(Fmt) ou BAR1(Fmt,...) en conséquence.

Ce:

#define HAS_COMMA(...) HAS_COMMA_16__(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)
#define HAS_COMMA_16__(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
#define CAT_(X,Y) X##Y
#define CAT(X,Y) CAT_(X,Y)
#define BAR(.../*All*/) CAT(BAR,HAS_COMMA(__VA_ARGS__))(__VA_ARGS__)
#define BAR0(X) printf(X "\n")
#define BAR1(X,...) printf(X "\n",__VA_ARGS__)


#include <stdio.h>
int main()
{
    BAR("here is a log message");
    BAR("here is a log message with a param: %d", 42);
}

compile avec -pedantic sans avertissement.

La solution standard est d'utiliser FOO au lieu de BAR. Il y a un peu étrange cas de l'argument de la réorganisation il ne peut probablement pas faire pour vous (même si je parie que quelqu'un peut venir avec des hacks pour démonter et remonter __VA_ARGS__ conditionnelle basée sur le nombre d'arguments dans la!) mais, en général, à l'aide de FOO "habituellement" fonctionne, tout simplement.