C préprocesseur, Macro « Surcharger »

Question

Je suis en train de faire une sorte de macro « surcharge », de sorte que MACRO (quelque chose), obtient élargi différemment MACRO (quelque chose, autre).

En utilisant un extrait que je suis de (je suis pas sûr si elle est 100% portable) et certaines fonctions de la bibliothèque Boost PP, j'ai pu le faire fonctionner: D

//THESE TWO COUNT THE NUMBER OF ARGUMENTS
#define VA_NARGS_IMPL(_1, _2, _3, _4, _5, N, ...) N
#define VA_NARGS(...) VA_NARGS_IMPL(__VA_ARGS__, 5, 4, 3, 2, 1)

//THIS ONE RETURNS THE PARAMETER AT POSITION _i FROM A LIST OF __VA_ARGS__
#define VA_ARG(_i, ...) BOOST_PP_ARRAY_ELEM(_i, (VA_NARGS(__VA_ARGS__), (__VA_ARGS__)))

//AND THIS ONE IS THE 'OVERLOADED' MACRO ;)
#define TEST(...) BOOST_PP_IF(BOOST_PP_EQUAL(1, VA_NARGS(__VA_ARGS__)), function_A(VA_ARG(0, __VA_ARGS__)), \ //1 parameter
                  BOOST_PP_IF(BOOST_PP_EQUAL(2, VA_NARGS(__VA_ARGS__)), function_B(VA_ARG(0, __VA_ARGS__) + VA_ARG(1, __VA_ARGS__)), \ //2 parameters
                  BOOST_PP_IF(BOOST_PP_EQUAL(3, VA_NARGS(__VA_ARGS__)), function_C(VA_ARG(1, __VA_ARGS__) + VA_ARG(2, __VA_ARGS__)), BOOST_PP_EMPTY())) // 3 parameters and so on ...

So       TEST(a) = function_A(a)
      TEST(a, b) = function_B(a + b)
   TEST(a, b, c) = function_C(b + c)

Maintenant, je manque encore deux autres choses que je veux faire:

1. Je crois (ce que je ne se soucient pas vraiment si je ne résous) qu'un MACRO peut être écrit que lors de la prise le nombre de « variantes » et son correspondant « sortie » génère un code similaire comme celle ci-dessus. Quelque chose comme TEMPLATE (3, function_A (...), function_B (...), function_C (...)) pour générer l'exemple ci-dessus.

2. Qu'est-ce qui se passe lorsque le test () est appelée sans arguments? Eh bien, VA_NARGS 1. Mais se développe pour le premier argument est « » (rien). J'essaie de trouver un moyen de détecter soit « zéro » dans les arguments __VA_ARGS__ ou de faire la différence entre un argument « nul » et un vrai, afin d'étendre la fonction « surcharge » pour réagir à cette situation. Toutes les idées?

Answer 1

Pour répondre à votre question 2 d'abord. Oui, avec des macros variadique il est également possible de détecter une liste d'arguments vide. L'explication est un peu long, je l'ai écrit en ici . Il devrait être relativement facile de combiner cette approche avec les macros boost que vous utilisez.

Pour votre question 1, oui ceci est également possible. Boost a quelques macros iterator qui se rapprochent de cela, je pense, mais ils ont l'air un peu effrayant à utiliser. Si je comprends bien, vous devez utiliser quelque chose comme (a, (b, (c,d))) listes imbriquées, pas trop commode.

(je l'ai écrit un ensemble de macros qui peuvent y parvenir plus directement, mais malheureusement, le paquet est pas encore prêt à être lancé. Contactez-moi en privé si vous êtes vraiment intéressé.)

Edit: package P99 est publié dans le même temps et contient beaucoup de choses sur macro « surcharge » et tapez macros génériques.