Можно избежать использования расширения GCC ,##__VA_ARGS__, если вы готовы принять определенный жестко заданный верхний предел количества аргументов, которые вы можете передать своему макросу с переменным числом аргументов, как описано в Ответ Ричарда Хансена на этот вопрос. Однако, если вы не хотите иметь такое ограничение, насколько мне известно, это невозможно использовать только функции препроцессора, указанные в C99; вы должны использовать какое-то расширение языка. clang и icc приняли это расширение GCC, а MSVC - нет.

Еще в 2001 году я написал расширение GCC для стандартизации (и связанное с ним расширение, которое позволяет вам использовать имя, отличное от __VA_ARGS__ для параметра rest) в документ N976, но никакого ответа от комитета на него не последовало; Я даже не знаю, читал ли это кто-нибудь. В 2016 году он был снова предложен в N2023, и я призываю всех, кто знает, как это предложение собирается сообщить нам об этом в комментариях.

Есть уловка с подсчетом аргументов, которую вы можете использовать.

Вот один из стандартных способов реализовать второй пример BAR() в вопросе jwd:

#include <stdio.h>

#define BAR(...) printf(FIRST(__VA_ARGS__) "\n" REST(__VA_ARGS__))

/* expands to the first argument */
#define FIRST(...) FIRST_HELPER(__VA_ARGS__, throwaway)
#define FIRST_HELPER(first, ...) first

/*
 * if there's only one argument, expands to nothing.  if there is more
 * than one argument, expands to a comma followed by everything but
 * the first argument.  only supports up to 9 arguments but can be
 * trivially expanded.
 */
#define REST(...) REST_HELPER(NUM(__VA_ARGS__), __VA_ARGS__)
#define REST_HELPER(qty, ...) REST_HELPER2(qty, __VA_ARGS__)
#define REST_HELPER2(qty, ...) REST_HELPER_##qty(__VA_ARGS__)
#define REST_HELPER_ONE(first)
#define REST_HELPER_TWOORMORE(first, ...) , __VA_ARGS__
#define NUM(...) \
    SELECT_10TH(__VA_ARGS__, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
#define SELECT_10TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, ...) a10

int
main(int argc, char *argv[])
{
    BAR("first test");
    BAR("second test: %s", "a string");
    return 0;
}

Этот же трюк используется для:

• подсчитайте количество аргументов
• расширять по-разному в зависимости от количества аргументов
• добавить в __VA_ARGS__

Объяснение

Стратегия состоит в том, чтобы разделить __VA_ARGS__ на первый аргумент и остальные (если есть). Это позволяет вставлять материал после первого аргумента, но перед вторым (если он присутствует).

FIRST()

Этот макрос просто расширяется до первого аргумента, отбрасывая остальные.

Реализация проста. Аргумент throwaway гарантирует, что FIRST_HELPER() получит два аргумента, что необходимо, потому что ... нужен хотя бы один. С одним аргументом он расширяется следующим образом:

1. FIRST(firstarg)
2. FIRST_HELPER(firstarg, throwaway)
3. firstarg

При наличии двух или более он расширяется следующим образом:

1. FIRST(firstarg, secondarg, thirdarg)
2. FIRST_HELPER(firstarg, secondarg, thirdarg, throwaway)
3. firstarg

REST()

Этот макрос расширяется до всего, кроме первого аргумента (включая запятую после первого аргумента, если аргументов больше одного).

Реализация этого макроса намного сложнее. Общая стратегия состоит в том, чтобы подсчитать количество аргументов (один или несколько), а затем расширить до REST_HELPER_ONE() (если задан только один аргумент) или до REST_HELPER_TWOORMORE() (если задано два или более аргумента). REST_HELPER_ONE() просто превращается в ничто - аргументов после первого нет, поэтому оставшиеся аргументы представляют собой пустой набор. REST_HELPER_TWOORMORE() также прост - он заменяется запятой, за которой следует все, кроме первого аргумента.

Аргументы подсчитываются с использованием макроса NUM(). Этот макрос расширяется до ONE, если задан только один аргумент, TWOORMORE, если задано от двух до девяти аргументов, и прерывается, если задано 10 или более аргументов (потому что он расширяется до 10-го аргумента).

Макрос NUM() использует макрос SELECT_10TH() для определения количества аргументов. Как следует из названия, SELECT_10TH() просто расширяется до своего 10-го аргумента. Из-за многоточия SELECT_10TH() необходимо передать не менее 11 аргументов (стандарт говорит, что для многоточия должен быть хотя бы один аргумент). Вот почему NUM() передает throwaway в качестве последнего аргумента (без него передача одного аргумента в NUM() приведет к передаче только 10 аргументов в SELECT_10TH(), что нарушит стандарт).

Выбор REST_HELPER_ONE() или REST_HELPER_TWOORMORE() выполняется путем объединения REST_HELPER_ с расширением NUM(__VA_ARGS__) в REST_HELPER2(). Обратите внимание, что цель REST_HELPER() - обеспечить полное раскрытие NUM(__VA_ARGS__) перед объединением с REST_HELPER_.

Расширение с одним аргументом выглядит следующим образом:

1. REST(firstarg)
2. REST_HELPER(NUM(firstarg), firstarg)
3. REST_HELPER2(SELECT_10TH(firstarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg)
4. REST_HELPER2(ONE, firstarg)
5. REST_HELPER_ONE(firstarg)
6. (пустой)

Расширение с двумя или более аргументами происходит следующим образом:

1. REST(firstarg, secondarg, thirdarg)
2. REST_HELPER(NUM(firstarg, secondarg, thirdarg), firstarg, secondarg, thirdarg)
3. REST_HELPER2(SELECT_10TH(firstarg, secondarg, thirdarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg, secondarg, thirdarg)
4. REST_HELPER2(TWOORMORE, firstarg, secondarg, thirdarg)
5. REST_HELPER_TWOORMORE(firstarg, secondarg, thirdarg)
6. , secondarg, thirdarg

Не общее решение, но в случае printf вы можете добавить новую строку, например:

#define BAR_HELPER(fmt, ...) printf(fmt "\n%s", __VA_ARGS__)
#define BAR(...) BAR_HELPER(__VA_ARGS__, "")

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

#define BAR_HELPER(fmt, ...) printf(fmt "\n", __VA_ARGS__)
#define BAR(...) BAR_HELPER(__VA_ARGS__, 0)

Я не могу поверить, что C99 был одобрен без стандартного способа сделать это. AFAICT проблема существует и в С ++ 11.

Есть способ справиться с этим конкретным случаем, используя что-то вроде Boost.Preprocessor. Вы можете использовать BOOST_PP_VARIADIC_SIZE, чтобы проверить размер списка аргументов, а затем условно расширить до другой макрос. Единственным недостатком этого метода является то, что он не может различить аргумент 0 и 1, и причина этого становится понятной, если вы рассмотрите следующее:

BOOST_PP_VARIADIC_SIZE()      // expands to 1
BOOST_PP_VARIADIC_SIZE(,)     // expands to 2
BOOST_PP_VARIADIC_SIZE(,,)    // expands to 3
BOOST_PP_VARIADIC_SIZE(a)     // expands to 1
BOOST_PP_VARIADIC_SIZE(a,)    // expands to 2
BOOST_PP_VARIADIC_SIZE(,b)    // expands to 2
BOOST_PP_VARIADIC_SIZE(a,b)   // expands to 2
BOOST_PP_VARIADIC_SIZE(a, ,c) // expands to 3

Список пустых аргументов макроса фактически состоит из одного пустого аргумента.

В этом случае нам повезло, поскольку у желаемого макроса всегда есть хотя бы 1 аргумент, мы можем реализовать его как два макроса «перегрузки»:

#define BAR_0(fmt) printf(fmt "\n")
#define BAR_1(fmt, ...) printf(fmt "\n", __VA_ARGS__)

А затем еще один макрос для переключения между ними, например:

#define BAR(...) \
    BOOST_PP_CAT(BAR_, BOOST_PP_GREATER(
        BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1))(__VA_ARGS__) \
    /**/

or

#define BAR(...) BOOST_PP_IIF( \
    BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1), \
        BAR_1, BAR_0)(__VA_ARGS__) \
    /**/

Что бы вы ни нашли более читаемым (я предпочитаю первый, поскольку он дает вам общую форму для перегрузки макросов по количеству аргументов).

Это также можно сделать с помощью одного макроса, обратившись к списку переменных аргументов и изменив его, но он менее читабелен и очень специфичен для этой проблемы:

#define BAR(...) printf( \
    BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) "\n" \
    BOOST_PP_COMMA_IF( \
        BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1)) \
    BOOST_PP_ARRAY_ENUM(BOOST_PP_ARRAY_POP_FRONT( \
        BOOST_PP_VARIADIC_TO_ARRAY(__VA_ARGS__)))) \
    /**/

Кроме того, почему нет BOOST_PP_ARRAY_ENUM_TRAILING? Это сделало бы это решение гораздо менее ужасным.

Изменить: Хорошо, вот BOOST_PP_ARRAY_ENUM_TRAILING и версия, в которой он используется (теперь это мое любимое решение):

#define BOOST_PP_ARRAY_ENUM_TRAILING(array) \
    BOOST_PP_COMMA_IF(BOOST_PP_ARRAY_SIZE(array)) BOOST_PP_ARRAY_ENUM(array) \
    /**/

#define BAR(...) printf( \
    BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) "\n" \
    BOOST_PP_ARRAY_ENUM_TRAILING(BOOST_PP_ARRAY_POP_FRONT( \
        BOOST_PP_VARIADIC_TO_ARRAY(__VA_ARGS__)))) \
    /**/

Очень простой макрос, который я использую для отладочной печати:

#define DBG__INT(fmt, ...) printf(fmt "%s", __VA_ARGS__);
#define DBG(...) DBG__INT(__VA_ARGS__, "\n")

int main() {
        DBG("No warning here");
        DBG("and we can add as many arguments as needed. %s", "nice!");
        return 0;
}

Независимо от того, сколько аргументов передается в DBG, предупреждение c99 отсутствует.

Уловка состоит в том, чтобы DBG__INT добавить фиктивный параметр, чтобы ... всегда имел хотя бы один аргумент и c99 был удовлетворен.

Недавно я столкнулся с подобной проблемой, и я верю, что есть решение.

Ключевая идея состоит в том, что есть способ написать макрос NUM_ARGS для подсчета количества аргументов, передаваемых макросу с переменным числом аргументов. Вы можете использовать вариант NUM_ARGS для построения NUM_ARGS_CEILING2, который может сказать вам, имеет ли вариативный макрос 1 аргумент или 2 или более аргументов. Затем вы можете написать свой макрос Bar так, чтобы он использовал NUM_ARGS_CEILING2 и CONCAT для отправки своих аргументов одному из двух вспомогательных макросов: один, который ожидает ровно 1 аргумент, и другой, который ожидает переменное количество аргументов больше 1.

Вот пример, в котором я использую этот трюк для написания макроса UNIMPLEMENTED, который очень похож на BAR:

ШАГ 1.

/** 
 * A variadic macro which counts the number of arguments which it is
 * passed. Or, more precisely, it counts the number of commas which it is
 * passed, plus one.
 *
 * Danger: It can't count higher than 20. If it's given 0 arguments, then it
 * will evaluate to 1, rather than to 0.
 */

#define NUM_ARGS(...)                                                   \
    NUM_ARGS_COUNTER(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13,       \
                     12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)    

#define NUM_ARGS_COUNTER(a1, a2, a3, a4, a5, a6, a7,        \
                         a8, a9, a10, a11, a12, a13,        \
                         a14, a15, a16, a17, a18, a19, a20, \
                         N, ...)                            \
    N

ШАГ 1.5.

/*
 * A variant of NUM_ARGS that evaluates to 1 if given 1 or 0 args, or
 * evaluates to 2 if given more than 1 arg. Behavior is nasty and undefined if
 * it's given more than 20 args.
 */

#define NUM_ARGS_CEIL2(...)                                           \
    NUM_ARGS_COUNTER(__VA_ARGS__, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
                     2, 2, 2, 2, 2, 2, 2, 1)

Шаг 2:

#define _UNIMPLEMENTED1(msg)                                        \
    log("My creator has forsaken me. %s:%s:%d." msg, __FILE__,      \
        __func__, __LINE__)

#define _UNIMPLEMENTED2(msg, ...)                                   \
    log("My creator has forsaken me. %s:%s:%d." msg, __FILE__,      \
        __func__, __LINE__, __VA_ARGS__)

ШАГ 3.

#define UNIMPLEMENTED(...)                                              \
    CONCAT(_UNIMPLEMENTED, NUM_ARGS_CEIL2(__VA_ARGS__))(__VA_ARGS__)

Где CONCAT реализован обычным образом. В качестве быстрой подсказки, если приведенное выше кажется сбивающим с толку: цель CONCAT заключается в расширении до другого макроса «call».

Обратите внимание, что сам NUM_ARGS не используется. Я просто включил его, чтобы проиллюстрировать здесь основной трюк. См. блог Йенса Густедта о P99, где он подробно описан.

Два примечания:

• NUM_ARGS ограничено числом обрабатываемых аргументов. Моя может обрабатывать только до 20, хотя это число может быть произвольным.

• NUM_ARGS, как показано, имеет ловушку, поскольку возвращает 1, когда задано 0 аргументов. Суть в том, что NUM_ARGS технически считает [запятые + 1], а не аргументы. В данном конкретном случае это действительно работает в наших интересах. _UNIMPLEMENTED1 прекрасно справится с пустым токеном и избавит нас от необходимости писать _UNIMPLEMENTED0. У Gustedt есть обходной путь для этого, хотя я не использовал его и не уверен, сработает ли он для того, что мы здесь делаем.