Макросчитать количество аргументов

У меня есть вариационная функция из сторонней библиотеки C:

int func(int argc, ...);

argc указывает количество переданных необязательных аргументов. Я обертываю его макросом, который подсчитывает количество аргументов, как предлагается здесь. Для удобства чтения здесь макрос:

#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

#define PP_NARG_(...)    PP_ARG_N(__VA_ARGS__)    

#define PP_NARG(...)     PP_NARG_(__VA_ARGS__, PP_RSEQ_N())

и я обертываю его так:

#define my_func(...)     func(PP_NARG(__VA_ARGS__), __VA_ARGS__)

Макрос PP_NARG отлично работает для функций, принимающих один или несколько аргументов. Например, PP_NARG("Hello", "World") оценивается как 2.

Проблема заключается в том, что когда аргументы не передаются, PP_NARG() оценивается 1 вместо 0.
Я понимаю как работает этот макрос, но я не могу придумать, как его изменить, чтобы он корректно вел себя и для этого случая.

Любые идеи?

ИЗМЕНИТЬ:
Я нашел обходное решение для PP_NARG и отправил его в качестве ответа.
Тем не менее, у меня все еще есть проблемы с упаковкой вариационной функции. Когда __VA_ARGS__ пуст, my_func расширяется до func(0, ), который вызывает ошибку компиляции.

ОТВЕТЫ

Ответ 1

Другая возможность, которая не использует sizeof и расширение GCC, заключается в добавлении следующего кода в ваш код

#define PP_COMMASEQ_N()                                    \
          1,  1,  1,  1,                                   \
          1,  1,  1,  1,  1,  1,  1,  1,  1,  1,           \
          1,  1,  1,  1,  1,  1,  1,  1,  1,  1,           \
          1,  1,  1,  1,  1,  1,  1,  1,  1,  1,           \
          1,  1,  1,  1,  1,  1,  1,  1,  1,  1,           \
          1,  1,  1,  1,  1,  1,  1,  1,  1,  1,           \
          1,  1,  1,  1,  1,  1,  1,  1,  0,  0

#define PP_COMMA(...)    ,

#define PP_HASCOMMA(...)                                   \
          PP_NARG_(__VA_ARGS__, PP_COMMASEQ_N())

#define PP_NARG(...)                                       \
          PP_NARG_HELPER1(                                 \
              PP_HASCOMMA(__VA_ARGS__),                    \
              PP_HASCOMMA(PP_COMMA __VA_ARGS__ ()),        \
              PP_NARG_(__VA_ARGS__, PP_RSEQ_N()))

#define PP_NARG_HELPER1(a, b, N)    PP_NARG_HELPER2(a, b, N)
#define PP_NARG_HELPER2(a, b, N)    PP_NARG_HELPER3_ ## a ## b(N)
#define PP_NARG_HELPER3_01(N)    0
#define PP_NARG_HELPER3_00(N)    1
#define PP_NARG_HELPER3_11(N)    N

Результат

PP_NARG()       // expands to 0
PP_NARG(x)      // expands to 1
PP_NARG(x, 2)   // expands to 2

Объяснение:

Трюк в этих макросах заключается в том, что PP_HASCOMMA(...) расширяется до 0 при вызове с нулевым или одним аргументом и до 1 при вызове с хотя бы двумя аргументами. Чтобы различать эти два случая, я использовал PP_COMMA __VA_ARGS__ (), который возвращает запятую, когда __VA_ARGS__ пуст, и ничего не возвращает, когда __VA_ARGS__ не является пустым.

Теперь возможны три случая:

  • __VA_ARGS__ пусто: PP_HASCOMMA(__VA_ARGS__) возвращает 0 и PP_HASCOMMA(PP_COMMA __VA_ARGS__ ()) возвращает 1.

  • __VA_ARGS__ содержит один аргумент: PP_HASCOMMA(__VA_ARGS__) возвращает 0 и PP_HASCOMMA(PP_COMMA __VA_ARGS__ ()) возвращает 0.

  • __VA_ARGS__ содержит два или более аргумента: PP_HASCOMMA(__VA_ARGS__) возвращает 1 и PP_HASCOMMA(PP_COMMA __VA_ARGS__ ()) возвращает 1.

Макросы PP_NARG_HELPERx необходимы только для разрешения этих случаев.

Edit:

Чтобы исправить проблему func(0, ), нам нужно проверить, поставили ли мы ноль или больше аргументов. Макрос PP_ISZERO вступает в игру здесь.

#define PP_ISZERO(x)    PP_HASCOMMA(PP_ISZERO_HELPER_ ## x)
#define PP_ISZERO_HELPER_0    ,

Теперь давайте определим другой макрос, который добавляет количество аргументов в список аргументов:

#define PP_PREPEND_NARG(...)                               \
          PP_PREPEND_NARG_HELPER1(PP_NARG(__VA_ARGS__), __VA_ARGS__)
#define PP_PREPEND_NARG_HELPER1(N, ...)                    \
          PP_PREPEND_NARG_HELPER2(PP_ISZERO(N), N, __VA_ARGS__)
#define PP_PREPEND_NARG_HELPER2(z, N, ...)                 \
          PP_PREPEND_NARG_HELPER3(z, N, __VA_ARGS__)
#define PP_PREPEND_NARG_HELPER3(z, N, ...)                 \
          PP_PREPEND_NARG_HELPER4_ ## z (N, __VA_ARGS__)
#define PP_PREPEND_NARG_HELPER4_1(N, ...)  0
#define PP_PREPEND_NARG_HELPER4_0(N, ...)  N, __VA_ARGS__

Многим помощникам снова необходимо расширить макросы до числовых значений. Наконец, протестируйте его:

#define my_func(...)  func(PP_PREPEND_NARG(__VA_ARGS__))

my_func()          // expands to func(0)
my_func(x)         // expands to func(1, x)
my_func(x, y)      // expands to func(2, x, y)
my_func(x, y, z)   // expands to func(3, x, y, z)

Пример онлайн:

http://coliru.stacked-crooked.com/a/73b4b6d75d45a1c8

См. также:

Просьба также посмотреть проект P99, который имеет гораздо больше расширенные препроцессорные решения, как это.

Ответ 2

В GCC можно использовать расширение ## 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

/* Note 63 is removed */
#define PP_RSEQ_N()                                        \
         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 PP_NARG_(...)    PP_ARG_N(__VA_ARGS__)    

/* Note dummy first argument _ and ##__VA_ARGS__ instead of __VA_ARGS__ */
#define PP_NARG(...)     PP_NARG_(_, ##__VA_ARGS__, PP_RSEQ_N())

#define my_func(...)     func(PP_NARG(__VA_ARGS__), __VA_ARGS__)

Теперь PP_NARG(a, b, c) дает 3 и PP_NARG() дает 0.

К сожалению, я не вижу способа заставить его работать вообще.

Ответ 3

Я придумал следующее обходное решение для PP_NARG:

#define PP_NARG(...)     (sizeof(#__VA_ARGS__) - 1 ?       \
    PP_NARG_(__VA_ARGS__, PP_RSEQ_N()) : 0)

Он строит __VA_ARGS__, поэтому, если он пуст, его длина равна 1 (потому что #__VA_ARGS__ == '\0').
Он работает с -std=c99 -pedantic.

У меня все еще есть проблемы с упаковкой вариационной функции. Когда __VA_ARGS__ пуст, my_func расширяется до func(0, ), который запускает ошибку компиляции.

Ответ 4

Полный пример ответа Mehrwolf, к сожалению, не компилируется на VS2010, ни он на VS2015 (я также попробовал это на this в сети VS компилятор). Другой подход к этой проблеме, который позволяет создавать кросс-платформенный код, который компилируется в широком диапазоне компиляторов, использует нестандартные расширения, которые также доступны в компиляторах MS, как в моем answer к аналогичному вопросу. Кроме того, по-другому формировать цитируемый ответ, результат PP_NARG((a, b, c)) с использованием расширений (как в компиляторах MS и gcc/clang) равен 1, а не 0.