Irgendein Korn
Einfache Frage, auf die ich im Netz keine Antwort finden konnte. Wie finde ich in variadischen Argumentmakros die Anzahl der Argumente? Ich bin mit dem Boost-Präprozessor einverstanden, wenn er die Lösung hat.
Wenn es einen Unterschied macht, versuche ich, eine variable Anzahl von Makroargumenten zu konvertieren, um die Präprozessorsequenz, Liste oder das Array für die weitere Neuverarbeitung zu verbessern.
Normalerweise verwende ich dieses Makro, um eine Reihe von Parametern zu finden:
#define NUMARGS(...) (sizeof((int[]){__VA_ARGS__})/sizeof(int))
Vollständiges Beispiel:
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#define NUMARGS(...) (sizeof((int[]){__VA_ARGS__})/sizeof(int))
#define SUM(...) (sum(NUMARGS(__VA_ARGS__), __VA_ARGS__))
void sum(int numargs, ...);
int main(int argc, char *argv[]) {
SUM(1);
SUM(1, 2);
SUM(1, 2, 3);
SUM(1, 2, 3, 4);
return 1;
}
void sum(int numargs, ...) {
int total = 0;
va_list ap;
printf("sum() called with %d params:", numargs);
va_start(ap, numargs);
while (numargs--)
total += va_arg(ap, int);
va_end(ap);
printf(" %d\n", total);
return;
}
Es ist ein vollständig gültiger C99-Code. Es hat jedoch einen Nachteil – Sie können das Makro nicht aufrufen SUM() ohne Parameter, aber GCC hat eine Lösung dafür – siehe Hier.
Im Fall von GCC müssen Sie also Makros wie folgt definieren:
#define NUMARGS(...) (sizeof((int[]){0, ##__VA_ARGS__})/sizeof(int)-1)
#define SUM(...) sum(NUMARGS(__VA_ARGS__), ##__VA_ARGS__)
und es funktioniert auch mit leerer Parameterliste
UM, es funktioniert nicht für das OP, er braucht die Größe für BOOST_PP, das zur Kompilierzeit ausgeführt wird.
– Kornel Kisielewicz
23. Januar 2010 um 19:50 Uhr
Klug! Funktioniert es auch wann sizeof(int) != sizeof(void *) ?
– Adam Liss
23. Januar 2010 um 19:52 Uhr
@Kornel Wie jedes Makro wird es zur Kompilierzeit ausgewertet. Ich habe keine Ahnung von Boost, aber Boost wird sowieso nicht benötigt.
– qrdl
23. Januar 2010 um 20:44 Uhr
@Adam Weil ich gecastet habe {__VA_ARGS__} zu int[]es ist nur int[]unabhängig vom tatsächlichen Inhalt von __VA_ARGS__
– qrdl
23. Januar 2010 um 20:45 Uhr
Elegante Lösung! Funktioniert in VS2017. Die ## wird in VS2017 nicht als leer benötigt __VA_ARGS__ entfernt automatisch alle vorangestellten Kommas.
– pobi
7. Oktober 2018 um 2:24 Uhr
Kornel Kisielewicz
Dies ist tatsächlich vom Compiler abhängig und wird von keinem Standard unterstützt.
Hier haben Sie jedoch eine Makro-Implementierung das zählt:
#define PP_NARG(...) \
PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) \
PP_ARG_N(__VA_ARGS__)
#define PP_ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63,N,...) N
#define PP_RSEQ_N() \
63,62,61,60, \
59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40, \
39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20, \
19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0
/* Some test cases */
PP_NARG(A) -> 1
PP_NARG(A,B) -> 2
PP_NARG(A,B,C) -> 3
PP_NARG(A,B,C,D) -> 4
PP_NARG(A,B,C,D,E) -> 5
PP_NARG(1,2,3,4,5,6,7,8,9,0,
1,2,3,4,5,6,7,8,9,0,
1,2,3,4,5,6,7,8,9,0,
1,2,3,4,5,6,7,8,9,0,
1,2,3,4,5,6,7,8,9,0,
1,2,3,4,5,6,7,8,9,0,
1,2,3) -> 63
….aber ist jetzt Standard in C++0x und hätte schon länger her sein sollen, da es eine großartige Möglichkeit bietet, varadische Funktionen vor beschädigten Aufrufen zu schützen (dh Sie können Werte nach den varadischen Elementen übergeben. Dies ist eigentlich eine Möglichkeit um die Zählung zu erhalten, die ich früher verwendet habe, aber ich denke, sizeof könnte auch funktionieren.
– Osirisgothra
4. Januar 2014 um 9:17 Uhr
Danke! das hat in Visual Studio 2013 für mich funktioniert: #define EXPAND(x) x #define PP_ARG_N(_1,_2,_3,_4,_5,_6,_7,_8,_9,N,...) N #define PP_NARG(...) EXPAND(PP_ARG_N(__VA_ARGS__, 9,8,7,6,5,4,3,2,1,0)) “`
– mchiasson
4. Juni 2015 um 15:06 Uhr
PP_NARG() kann nicht 0 zurückgeben GET_ARG_COUNT() & Y_TUPLE_SIZE() Lösungen funktionieren.
– PSkočik
26. Juli 2016 um 11:13 Uhr
“PP_NARG() liefert keine 0 zurück” … ist nicht unbedingt ein Problem. Das kann man so sagen PP_NARG() sollte geben Sie 1 aus dem gleichen Grund zurück PP_NARG(,) sollte zurückkehren 2. Erkennen 0 kann in einigen Fällen tatsächlich praktisch sein, aber die Lösungen scheinen entweder weniger allgemein zu sein (wobei es erforderlich ist, dass das erste Token eingefügt werden kann; was dürfen oder nicht dürfen je nachdem, wofür Sie es verwenden, in Ordnung sein) oder implementierungsspezifisch (z.
– H Walters
16. Juni 2017 um 5:13 Uhr
Doppelte/verwandte Antworten: 1) stackoverflow.com/questions/11761703/… und 2) (diese hilft mir zu sehen, was anfangs einfacher passiert, da es ein kürzeres Makro ist): stackoverflow.com/questions/11761703/…
– Gabriel Staples
5. März 2020 um 20:52 Uhr
Maciek Gajewski
Wenn Sie C++11 verwenden und den Wert als C++-Kompilierzeitkonstante benötigen, ist dies eine sehr elegante Lösung:
#include <tuple>
#define MACRO(...) \
std::cout << "num args: " \
<< std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value \
<< std::endl;
Bitte beachten Sie: Die Zählung erfolgt vollständig zur Kompilierzeit, und der Wert kann immer dann verwendet werden, wenn eine Ganzzahl zur Kompilierzeit erforderlich ist, beispielsweise als Vorlagenparameter für std::array.
Tolle Lösung! Und anders sizeof((int[]){__VA_ARGS__})/sizeof(int) oben vorgeschlagen, funktioniert es auch dann, wenn die Argumente nicht alle umgesetzt werden können int.
– Wim
21. Juni 2016 um 9:14 Uhr
Einverstanden. Tolle Lösung! ++.
– Davernator
3. August 2019 um 20:55 Uhr
Funktioniert nicht mit Vorlagen, dh NUMARGS( sum<1,2> ); sehen godbolt.org/z/_AAxmL
– jorgbraun
9. Oktober 2019 um 22:37 Uhr
Ich denke, dass könnte tatsächlich ein Argument dafür sein, @jorgbrown, zumindest in den meisten Fällen, in denen es auftaucht. Da es sich auf den Compiler und nicht auf den Präprozessor verlässt, um das Zählen durchzuführen, gibt es die Anzahl der Argumente aus, wie sie vom Compiler gesehen werden, was wahrscheinlich mit dem übereinstimmt, was die meisten Programmierer erwarten. Es Wille Probleme verursachen, wenn Sie erwarten, dass es die Präprozessor-Gierigkeit berücksichtigt.
– Justin Time – Wiedereinsetzung von Monica
29. Oktober 2019 um 18:30 Uhr
Super Antwort. Sie können es in ein Makro einfügen #define NUM_ARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
– Richard Weißkopf
18. Juni 2020 um 10:05 Uhr
Chris Klin
Der Einfachheit halber ist hier eine Implementierung, die für 0 bis 70 Argumente funktioniert und in Visual Studio funktioniert. GCC und Clang. Ich glaube, es wird in Visual Studio 2010 und höher funktionieren, habe es aber nur in VS2013 getestet.
#ifdef _MSC_VER // Microsoft compilers
# define GET_ARG_COUNT(...) INTERNAL_EXPAND_ARGS_PRIVATE(INTERNAL_ARGS_AUGMENTER(__VA_ARGS__))
# define INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
# define INTERNAL_EXPAND(x) x
# define INTERNAL_EXPAND_ARGS_PRIVATE(...) INTERNAL_EXPAND(INTERNAL_GET_ARG_COUNT_PRIVATE(__VA_ARGS__, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
# define INTERNAL_GET_ARG_COUNT_PRIVATE(_1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, _33_, _34_, _35_, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, count, ...) count
#else // Non-Microsoft compilers
# define GET_ARG_COUNT(...) INTERNAL_GET_ARG_COUNT_PRIVATE(0, ## __VA_ARGS__, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
# define INTERNAL_GET_ARG_COUNT_PRIVATE(_0, _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, _33_, _34_, _35_, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, count, ...) count
#endif
static_assert(GET_ARG_COUNT() == 0, "GET_ARG_COUNT() failed for 0 arguments");
static_assert(GET_ARG_COUNT(1) == 1, "GET_ARG_COUNT() failed for 1 argument");
static_assert(GET_ARG_COUNT(1,2) == 2, "GET_ARG_COUNT() failed for 2 arguments");
static_assert(GET_ARG_COUNT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70) == 70, "GET_ARG_COUNT() failed for 70 arguments");
Es gibt einige C ++ 11-Lösungen zum Ermitteln der Anzahl der Argumente zur Kompilierzeit, aber ich bin überrascht zu sehen, dass niemand etwas so Einfaches vorgeschlagen hat wie:
#define VA_COUNT(...) detail::va_count(__VA_ARGS__)
namespace detail
{
template<typename ...Args>
constexpr std::size_t va_count(Args&&...) { return sizeof...(Args); }
}
Dies erfordert keine Einbeziehung der <tuple> Kopfzeile auch nicht.
“aber warum nicht einfach eine variadische Vorlage und Größe von … verwenden (wie in meiner eigenen Antwort)” c++ ist zu einem Monster geworden. Es hat zu viele Funktionen und viele davon, wie z. B. verschiedene Vorlagen, werden selten verwendet. Du liest darüber, schreibst ein paar Beispiele und dann vergisst du es. Daher ist es schwierig, zur richtigen Zeit auf die richtige Idee zu kommen. Da Ihre Lösung eine bessere Option zu sein scheint als meine, werde ich die natürliche Selektion arbeiten lassen und meine Lösung löschen.
– zdf
11. Mai 2018 um 10:36 Uhr
@ZDF verständlich, aber ich verwende ständig variadische Vorlagen. Meine Programme sind seit C++11 viel robuster geworden, und das ist einer der Hauptgründe dafür. Ich denke, Sie müssen Ihre Antwort jedoch nicht löschen.
– Affe0506
11. Mai 2018 um 14:01 Uhr
Mit so etwas wird es nicht funktionieren VA_COUNT(&,^,%). Auch wenn Sie über eine Funktion zählen, sehe ich keinen Sinn darin, ein Makro zu erstellen.
– Qwertiy
15. August 2018 um 23:39 Uhr
Diese Lösung bleibt eine Frage: Die Parameter von VA_COUNT sind alle Bezeichner, die noch nicht als Variable oder so definiert sind, und es verursacht den Fehler ‘*** Variable ist nicht definiert’. Gibt es eine Möglichkeit, dies zu beheben?
– ipid
18. Mai 2019 um 10:08 Uhr
Im Rahmen der Norm C++ das ist die richtige antwort. Makro nicht erforderlich. godbolt.org/z/varbM6r69
– Chef Gladiator
27. Februar um 10:30 Uhr
dies funktioniert mit 0 Argumenten mit gcc/llvm.
[links are dumb]
/*
* we need a comma at the start for ##_VA_ARGS__ to consume then
* the arguments are pushed out in such a way that 'cnt' ends up with
* the right count.
*/
#define COUNT_ARGS(...) COUNT_ARGS_(,##__VA_ARGS__,6,5,4,3,2,1,0)
#define COUNT_ARGS_(z,a,b,c,d,e,f,cnt,...) cnt
#define C_ASSERT(test) \
switch(0) {\
case 0:\
case test:;\
}
int main() {
C_ASSERT(0 == COUNT_ARGS());
C_ASSERT(1 == COUNT_ARGS(a));
C_ASSERT(2 == COUNT_ARGS(a,b));
C_ASSERT(3 == COUNT_ARGS(a,b,c));
C_ASSERT(4 == COUNT_ARGS(a,b,c,d));
C_ASSERT(5 == COUNT_ARGS(a,b,c,d,e));
C_ASSERT(6 == COUNT_ARGS(a,b,c,d,e,f));
return 0;
}
Visual Studio scheint den ##-Operator zu ignorieren, der verwendet wird, um das leere Argument zu verwenden. Das kannst du wahrscheinlich mit sowas umgehen
#define CNT_ COUNT_ARGS
#define PASTE(x,y) PASTE_(x,y)
#define PASTE_(x,y) x ## y
#define CNT(...) PASTE(ARGVS,PASTE(CNT_(__VA_ARGS__),CNT_(1,##__VA_ARGS__)))
//you know its 0 if its 11 or 01
#define ARGVS11 0
#define ARGVS01 0
#define ARGVS12 1
#define ARGVS23 2
#define ARGVS34 3
“aber warum nicht einfach eine variadische Vorlage und Größe von … verwenden (wie in meiner eigenen Antwort)” c++ ist zu einem Monster geworden. Es hat zu viele Funktionen und viele davon, wie z. B. verschiedene Vorlagen, werden selten verwendet. Du liest darüber, schreibst ein paar Beispiele und dann vergisst du es. Daher ist es schwierig, zur richtigen Zeit auf die richtige Idee zu kommen. Da Ihre Lösung eine bessere Option zu sein scheint als meine, werde ich die natürliche Selektion arbeiten lassen und meine Lösung löschen.
– zdf
11. Mai 2018 um 10:36 Uhr
@ZDF verständlich, aber ich verwende ständig variadische Vorlagen. Meine Programme sind seit C++11 viel robuster geworden, und das ist einer der Hauptgründe dafür. Ich denke, Sie müssen Ihre Antwort jedoch nicht löschen.
– Affe0506
11. Mai 2018 um 14:01 Uhr
Mit so etwas wird es nicht funktionieren VA_COUNT(&,^,%). Auch wenn Sie über eine Funktion zählen, sehe ich keinen Sinn darin, ein Makro zu erstellen.
– Qwertiy
15. August 2018 um 23:39 Uhr
Diese Lösung bleibt eine Frage: Die Parameter von VA_COUNT sind alle Bezeichner, die noch nicht als Variable oder so definiert sind, und es verursacht den Fehler ‘*** Variable ist nicht definiert’. Gibt es eine Möglichkeit, dies zu beheben?
– ipid
18. Mai 2019 um 10:08 Uhr
Im Rahmen der Norm C++ das ist die richtige antwort. Makro nicht erforderlich. godbolt.org/z/varbM6r69
– Chef Gladiator
27. Februar um 10:30 Uhr
Mit msvc-Erweiterung:
#define Y_TUPLE_SIZE(...) Y_TUPLE_SIZE_II((Y_TUPLE_SIZE_PREFIX_ ## __VA_ARGS__ ## _Y_TUPLE_SIZE_POSTFIX,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))
#define Y_TUPLE_SIZE_II(__args) Y_TUPLE_SIZE_I __args
#define Y_TUPLE_SIZE_PREFIX__Y_TUPLE_SIZE_POSTFIX ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,0
#define Y_TUPLE_SIZE_I(__p0,__p1,__p2,__p3,__p4,__p5,__p6,__p7,__p8,__p9,__p10,__p11,__p12,__p13,__p14,__p15,__p16,__p17,__p18,__p19,__p20,__p21,__p22,__p23,__p24,__p25,__p26,__p27,__p28,__p29,__p30,__p31,__n,...) __n
Funktioniert für 0 – 32 Argumente. Diese Grenze kann leicht erweitert werden.
BEARBEITEN: Vereinfachte Version (funktioniert in VS2015 14.0.25431.01 Update 3 & gcc 7.4.0) bis zu 100 Argumente zum Kopieren und Einfügen:
#define COUNTOF(...) _COUNTOF_CAT( _COUNTOF_A, ( 0, ##__VA_ARGS__, 100,\
99, 98, 97, 96, 95, 94, 93, 92, 91, 90,\
89, 88, 87, 86, 85, 84, 83, 82, 81, 80,\
79, 78, 77, 76, 75, 74, 73, 72, 71, 70,\
69, 68, 67, 66, 65, 64, 63, 62, 61, 60,\
59, 58, 57, 56, 55, 54, 53, 52, 51, 50,\
49, 48, 47, 46, 45, 44, 43, 42, 41, 40,\
39, 38, 37, 36, 35, 34, 33, 32, 31, 30,\
29, 28, 27, 26, 25, 24, 23, 22, 21, 20,\
19, 18, 17, 16, 15, 14, 13, 12, 11, 10,\
9, 8, 7, 6, 5, 4, 3, 2, 1, 0 ) )
#define _COUNTOF_CAT( a, b ) a b
#define _COUNTOF_A( a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,\
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,\
a20, a21, a22, a23, a24, a25, a26, a27, a28, a29,\
a30, a31, a32, a33, a34, a35, a36, a37, a38, a39,\
a40, a41, a42, a43, a44, a45, a46, a47, a48, a49,\
a50, a51, a52, a53, a54, a55, a56, a57, a58, a59,\
a60, a61, a62, a63, a64, a65, a66, a67, a68, a69,\
a70, a71, a72, a73, a74, a75, a76, a77, a78, a79,\
a80, a81, a82, a83, a84, a85, a86, a87, a88, a89,\
a90, a91, a92, a93, a94, a95, a96, a97, a98, a99,\
a100, n, ... ) n
Bin ich es nur oder verstößt das irgendwie gegen die Code-Geruchsregeln?
– Osirisgothra
4. Januar 2014 um 9:19 Uhr
Es funktioniert für mich mit VC ++ bis mindestens VS2012 und GCC und Clang in meinen grundlegenden Tests.
– ThreeBit
23. März 2014 um 18:53 Uhr
@osirisgothra, genau warum riecht es?
– ceztko
2. November 2014 um 22:59 Uhr
Obwohl dieses Makro eine breite Compiler-Unterstützung bietet, funktioniert es nicht mit Makroargumenten wie einer Zeichenfolge, wie z Y_TUPLE_SIZE("Hello"), was es ziemlich unmöglich macht. Ich stimme @osirisgothra zu.
– ceztko
15. Dezember 2014 um 11:23 Uhr
Dieses Makro kann für Sie funktionieren, weist jedoch schwerwiegende Mängel auf. Ich habe viel recherchiert und sauberere Ansätze gefunden, die in GCC und VS funktionieren. Sie finden sie in meiner Antwort auf eine ähnliche Frage.
– ceztko
28. Februar 2015 um 1:01 Uhr
Nur um das klarzustellen – Sie fragen nach variadischen Makros und nicht nach den Makros, die zum Erstellen variadischer C-Funktionen verwendet werden?
– anon
23. Januar 2010 um 19:23 Uhr
Sind die Argumente vom gleichen Typ? wenn ja, und wenn der Typ bekannt ist, gibt es eine Standard-C-Lösung über zusammengesetzte Literale; wenn es unbekannt ist, könnten Sie verwenden
__typeof__um es zumindest auf einigen Compilern zum Laufen zu bringen– Christoph
23. Januar 2010 um 19:24 Uhr
Da es in der Diskussion um die Boost-Präprozessorsequenz usw. geht, muss es sich um C++ handeln (weshalb ich das Q neu markiert habe – aber den Titel der Frage nicht geändert habe) … Ups; Ich werde das beheben.
– Jonathan Leffler
23. Januar 2010 um 19:25 Uhr
@JonathanLeffler Stimmt, Boost ist eine C++-Bibliothek. Boost.Preprocessor kann jedoch mit C verwendet werden. AFAIK, nichts, was es verwendet, ist C++ spezifisch.
– Justin
20. Dezember 2018 um 16:13 Uhr
Siehe auch: stackoverflow.com/questions/11761703/…
– Gabriel Staples
5. März 2020 um 20:41 Uhr