Mit größtem Respekt an Derek Ledbetter , David Sorkovsky , Syphorlate für ihre Antworten, zusammen mit der genialen Methode, leere Makroargumente von Jens Gustedt bei zu erkennen
https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
Schließlich komme ich mit etwas heraus, das alle Tricks enthält, so dass die Lösung
- Verwendet nur Standard-C99- Makros, um eine Funktionsüberladung zu erreichen, ohne dass eine GCC / CLANG / MSVC-Erweiterung beteiligt ist (dh Komma-Schlucken durch den spezifischen Ausdruck
, ##__VA_ARGS__für GCC / CLANG und implizites Schlucken durch ##__VA_ARGS__für MSVC). --std=c99Wenn Sie möchten, können Sie das Fehlende an Ihren Compiler weitergeben =)
- Funktioniert für Null-Argumente sowie für eine unbegrenzte Anzahl von Argumenten , wenn Sie es weiter erweitern, um es Ihren Anforderungen anzupassen
Funktioniert einigermaßen plattformübergreifend , zumindest getestet
- GNU / Linux + GCC (GCC 4.9.2 unter CentOS 7.0 x86_64)
- GNU / Linux + CLANG / LLVM (CLANG / LLVM 3.5.0 unter CentOS 7.0 x86_64)
- OS X + Xcode (XCode 6.1.1 unter OS X Yosemite 10.10.1)
- Windows + Visual Studio (Visual Studio 2013 Update 4 unter Windows 7 SP1 64 Bit)
Für die Faulen springen Sie einfach zum letzten Teil dieses Beitrags, um die Quelle zu kopieren. Nachfolgend finden Sie eine ausführliche Erklärung, die hoffentlich allen Menschen hilft und sie inspiriert, die nach allgemeinen __VA_ARGS__Lösungen wie mir suchen . =)
So geht's Definieren Sie zunächst den Benutzer sichtbaren überlastete „Funktion“, nannte ich es create, und die tatsächliche Funktionsdefinition verwendet realCreate, und die Makrodefinitionen mit unterschiedlicher Anzahl von Argumenten CREATE_2, CREATE_1, CREATE_0, wie unten dargestellt:
#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)
Der MACRO_CHOOSER(__VA_ARGS__)Teil wird schließlich in die Makrodefinitionsnamen aufgelöst, und der zweite (__VA_ARGS__)Teil enthält deren Parameterlisten. So ein Anruf des Benutzers zu create(10)Entschlüssen zu CREATE_1(10), das CREATE_1kommt teilweise aus MACRO_CHOOSER(__VA_ARGS__), und das (10)Teil stammt aus dem zweiten(__VA_ARGS__) .
Der MACRO_CHOOSERverwendet den Trick, dass __VA_ARGS__der folgende Ausdruck , wenn er leer ist, vom Präprozessor zu einem gültigen Makroaufruf verkettet wird:
NO_ARG_EXPANDER __VA_ARGS__ () // simply shrinks to NO_ARG_EXPANDER()
Genialerweise können wir diesen resultierenden Makroaufruf als definieren
#define NO_ARG_EXPANDER() ,,CREATE_0
Beachten Sie die beiden Kommas, sie werden bald erklärt. Das nächste nützliche Makro ist
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())
so die Anrufe von
create();
create(10);
create(20, 20);
sind eigentlich erweitert auf
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);
Wie der Makroname andeutet, müssen wir später die Anzahl der Argumente zählen. Hier kommt ein weiterer Trick: Der Präprozessor ersetzt nur den einfachen Text. Die Anzahl der Argumente eines Makroaufrufs wird lediglich aus der Anzahl der Kommas in den Klammern abgeleitet. Die durch Kommas getrennten tatsächlichen "Argumente" müssen keine gültige Syntax haben. Sie können ein beliebiger Text sein. Das heißt, im obigen Beispiel NO_ARG_EXPANDER 10 ()wird als 1 Argument für den mittleren Aufruf gezählt. NO_ARG_EXPANDER 20und20 () werden jeweils als 2 Argumente für den untersten Aufruf gezählt.
Wenn wir die folgenden Hilfsmakros verwenden, um sie weiter zu erweitern
##define CHOOSE_FROM_ARG_COUNT(...) \
FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define FUNC_RECOMPOSER(argsWithParentheses) \
FUNC_CHOOSER argsWithParentheses
Das anschließende ,Nach CREATE_1ist eine Problemumgehung für GCC / CLANG, die einen (falsch positiven) Fehler unterdrückt, der besagt, dass dies ISO C99 requires rest arguments to be usedbei der Übergabe -pedantican Ihren Compiler der Fall ist . Das FUNC_RECOMPOSERist eine Behelfslösung für MSVC, oder es kann nicht mehr Argumente zählt (dh Komma) in den Klammern der Makroaufrufe richtig. Die Ergebnisse werden weiter aufgelöst
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);
Wie Sie vielleicht gesehen haben, besteht der letzte Schritt darin, einen Standard-Trick zum Zählen von Argumenten anzuwenden, um schließlich die gewünschten Namen der Makroversionen auszuwählen:
#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
das löst die Ergebnisse auf
CREATE_0();
CREATE_1(10);
CREATE_2(20, 20);
und gibt uns sicherlich die gewünschten, tatsächlichen Funktionsaufrufe:
realCreate(0, 0);
realCreate(10, 10);
realCreate(20, 20);
Alles in allem ist die gesamte Quelle des Beispiels mit zwei Argumenten hier , wobei einige Anweisungen zur besseren Lesbarkeit neu angeordnet wurden :
#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;
}
Obwohl kompliziert, hässlich und den API-Entwickler belastend, gibt es eine Lösung zum Überladen und Festlegen optionaler Parameter von C / C ++ - Funktionen für uns Verrückte. Die Verwendung der ausgehenden überlasteten APIs wird sehr angenehm und angenehm. =)
Wenn es eine weitere mögliche Vereinfachung dieses Ansatzes gibt, lassen Sie es mich bitte unter wissen
https://github.com/jason-deng/C99FunctionOverload
Nochmals ein besonderer Dank an alle brillanten Menschen, die mich zu dieser Arbeit inspiriert und geführt haben! =)