Avec le plus grand respect à Derek Ledbetter , David Sorkovsky , Syphorlate pour leurs réponses, ainsi que la méthode ingénieuse pour détecter les macro-arguments vides de Jens Gustedt à
https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
enfin je viens avec quelque chose qui incorpore toutes les astuces, de sorte que la solution
- Utilise uniquement des macros C99 standard pour réaliser une surcharge de fonction, aucune extension GCC / CLANG / MSVC impliquée (c'est-à-dire, une virgule avalée par l'expression spécifique
, ##__VA_ARGS__pour GCC / CLANG et une avalée implicite par ##__VA_ARGS__pour MSVC). Alors n'hésitez pas à transmettre le manquant --std=c99à votre compilateur si vous le souhaitez =)
- Fonctionne pour zéro argument , ainsi qu'un nombre illimité d'arguments , si vous l'étendez davantage pour répondre à vos besoins
Fonctionne raisonnablement multiplateforme , au moins testé pour
- GNU / Linux + GCC (GCC 4.9.2 sur CentOS 7.0 x86_64)
- GNU / Linux + CLANG / LLVM , (CLANG / LLVM 3.5.0 sur CentOS 7.0 x86_64)
- OS X + Xcode , (XCode 6.1.1 sur OS X Yosemite 10.10.1)
- Windows + Visual Studio , (Visual Studio 2013 Update 4 sur Windows 7 SP1 64 bits)
Pour les paresseux, passez simplement au tout dernier de cet article pour copier la source. Vous trouverez ci-dessous l'explication détaillée qui, espérons-le, aide et inspire toutes les personnes à la recherche de __VA_ARGS__solutions générales comme moi. =)
Voici comment ça se passe. Tout d' abord définir la « fonction » surcharge utilisateur visible, je l' ai appelé create, et la définition de la fonction réelle liée realCreate, et les définitions de macros avec nombre différent d'arguments CREATE_2, CREATE_1, CREATE_0comme indiqué ci - dessous:
#define create(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)
void realCreate(int x, int y)
{
printf("(%d, %d)\n", x, y);
}
#define CREATE_2(x, y) realCreate(x, y)
#define CREATE_1(x) CREATE_2(x, 0)
#define CREATE_0() CREATE_1(0)
La MACRO_CHOOSER(__VA_ARGS__)partie résout finalement les noms de définition de macro, et la deuxième (__VA_ARGS__)partie comprend leurs listes de paramètres. Ainsi, l'appel d'un utilisateur à se create(10)résout à CREATE_1(10), la CREATE_1pièce vient de MACRO_CHOOSER(__VA_ARGS__), et la (10)pièce vient de la seconde (__VA_ARGS__).
Le MACRO_CHOOSERutilise l'astuce que, si elle __VA_ARGS__est vide, l'expression suivante est concaténée en un appel de macro valide par le préprocesseur:
NO_ARG_EXPANDER __VA_ARGS__ () // simply shrinks to NO_ARG_EXPANDER()
Ingénieusement, nous pouvons définir cet appel de macro résultant comme
#define NO_ARG_EXPANDER() ,,CREATE_0
Notez les deux virgules, elles sont expliquées bientôt. La prochaine macro utile est
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())
donc les appels de
create();
create(10);
create(20, 20);
sont en fait étendus à
CHOOSE_FROM_ARG_COUNT(,,CREATE_0)();
CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER 10 ())(10);
CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER 20, 20 ())(20, 20);
Comme le nom de la macro l'indique, nous devons compter le nombre d'arguments plus tard. Voici une autre astuce: le préprocesseur ne fait qu'un simple remplacement de texte. Il déduit le nombre d'arguments d'un appel de macro simplement à partir du nombre de virgules qu'il voit à l'intérieur des parenthèses. Les "arguments" réels séparés par des virgules n'ont pas besoin d'être de syntaxe valide. Ils peuvent être n'importe quel texte. C'est-à-dire que, dans l'exemple ci-dessus, NO_ARG_EXPANDER 10 ()est compté comme 1 argument pour l'appel du milieu. NO_ARG_EXPANDER 20et 20 ()sont comptés comme 2 arguments pour l'appel du bas respectivement.
Si nous utilisons les macros d'assistance suivantes pour les développer davantage
##define CHOOSE_FROM_ARG_COUNT(...) \
FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define FUNC_RECOMPOSER(argsWithParentheses) \
FUNC_CHOOSER argsWithParentheses
La fin ,après CREATE_1est une solution de contournement pour GCC / CLANG, supprimant une erreur (faux positif) indiquant cela ISO C99 requires rest arguments to be usedlors du passage -pedanticà votre compilateur. Il FUNC_RECOMPOSERs'agit d'une solution de contournement pour MSVC, ou il ne peut pas compter correctement le nombre d'arguments (c'est-à-dire, des virgules) entre les parenthèses des appels de macro. Les résultats sont en outre résolus à
FUNC_CHOOSER (,,CREATE_0, CREATE_2, CREATE_1, )();
FUNC_CHOOSER (NO_ARG_EXPANDER 10 (), CREATE_2, CREATE_1, )(10);
FUNC_CHOOSER (NO_ARG_EXPANDER 20, 20 (), CREATE_2, CREATE_1, )(20, 20);
Comme vous l'avez peut-être vu, la dernière étape dont nous avons besoin est d'utiliser une astuce de comptage d'arguments standard pour enfin choisir les noms de version de macro voulus:
#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
qui résout les résultats à
CREATE_0();
CREATE_1(10);
CREATE_2(20, 20);
et nous donne certainement les appels de fonction souhaités et réels:
realCreate(0, 0);
realCreate(10, 10);
realCreate(20, 20);
En réunissant le tout, avec un réarrangement des instructions pour une meilleure lisibilité, toute la source de l'exemple à 2 arguments est ici:
#include <stdio.h>
void realCreate(int x, int y)
{
printf("(%d, %d)\n", x, y);
}
#define CREATE_2(x, y) realCreate(x, y)
#define CREATE_1(x) CREATE_2(x, 0)
#define CREATE_0() CREATE_1(0)
#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
#define FUNC_RECOMPOSER(argsWithParentheses) FUNC_CHOOSER argsWithParentheses
#define CHOOSE_FROM_ARG_COUNT(...) FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define NO_ARG_EXPANDER() ,,CREATE_0
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())
#define create(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)
int main()
{
create();
create(10);
create(20, 20);
//create(30, 30, 30); // Compilation error
return 0;
}
Bien que compliqué, laid, pesant sur le développeur d'API, il existe une solution pour surcharger et définir les paramètres optionnels des fonctions C / C ++ pour nous les fous. L'utilisation des API surchargées sortantes devient très agréable et agréable. =)
S'il y a une autre simplification possible de cette approche, veuillez me le faire savoir à
https://github.com/jason-deng/C99FunctionOverload
Encore une fois un merci spécial à toutes les personnes brillantes qui m'ont inspiré et conduit à réaliser ce travail! =)