C++-Präprozessor __VA_ARGS__ Anzahl von Argumenten

Lesezeit: 12 Minuten

C Praprozessor VA ARGS Anzahl von Argumenten
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.

  • 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

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

C Praprozessor VA ARGS Anzahl von Argumenten
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

1647103813 586 C Praprozessor VA ARGS Anzahl von Argumenten
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

1647103813 170 C Praprozessor VA ARGS Anzahl von Argumenten
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


994420cookie-checkC++-Präprozessor __VA_ARGS__ Anzahl von Argumenten

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy