C99中有一个well-known problem个可变参数宏的空args。
示例：
#define FOO(...) printf(__VA_ARGS__)
#define BAR(fmt, ...) printf(fmt, __VA_ARGS__)
FOO("this works fine");
BAR("this breaks!");
根据C99标准，使用上述BAR()确实不正确，因为它将扩展为：
printf("this breaks!",);
注意尾随逗号 - 不可行。
有些编译器（例如：Visual Studio 2010）会悄悄地为你删除那个尾随的逗号。其他编译器（例如：GCC）支持将##放在__VA_ARGS__之前，如下所示：
#define BAR(fmt, ...) printf(fmt, ##__VA_ARGS__)
但有没有符合标准的方法来获得这种行为？ 也许使用多个宏？
目前，##版似乎得到了相当好的支持（至少在我的平台上），但我真的更喜欢使用符合标准的解决方案。
编辑：以下是我想要使用BAR（）的一个例子（虽然很简单）：
#define BAR(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
BAR("here is a log message");
BAR("here is a log message with a param: %d", 42);
这会自动为我的BAR（）日志记录语句添加换行符，假设fmt始终是双引号C字符串。它不会将换行符打印为单独的printf（），如果日志记录是行缓冲的并且是异步来自多个源，这是有利的。
答案 0 :(得分：106)
你可以使用一个参数计数技巧。
这是在jwd的问题中实现第二个BAR()示例的一种符合标准的方法：
#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()获取两个参数，这是必需的，因为...至少需要一个参数。只有一个参数，它扩展如下：
FIRST(firstarg) FIRST_HELPER(firstarg, throwaway) firstarg 有两个或更多，它扩展如下：
FIRST(firstarg, secondarg, thirdarg) FIRST_HELPER(firstarg, secondarg, thirdarg, throwaway) firstarg REST() 此宏扩展到除第一个参数之外的所有内容（如果有多个参数，则包括第一个参数后面的逗号）。
这个宏的实现要复杂得多。一般策略是计算参数的数量（一个或多个），然后扩展到REST_HELPER_ONE()（如果只给出一个参数）或REST_HELPER_TWOORMORE()（如果给出两个或多个参数）。 REST_HELPER_ONE()只是扩展为空 - 在第一个之后没有参数，所以剩下的参数是空集。 REST_HELPER_TWOORMORE()也很简单 - 它会扩展为逗号，后跟除第一个参数之外的所有内容。
使用NUM()宏计算参数。如果只给出一个参数，则此宏扩展为ONE，如果给出两个和九个参数，则扩展为TWOORMORE，如果给出10个或更多个参数，则该宏断开（因为它扩展到第10个参数）。 / p>
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_连接之前完全展开。
使用一个参数进行扩展如下：
REST(firstarg) REST_HELPER(NUM(firstarg), firstarg) REST_HELPER2(SELECT_10TH(firstarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg) REST_HELPER2(ONE, firstarg) REST_HELPER_ONE(firstarg) 使用两个或多个参数进行扩展如下：
REST(firstarg, secondarg, thirdarg) REST_HELPER(NUM(firstarg, secondarg, thirdarg), firstarg, secondarg, thirdarg) REST_HELPER2(SELECT_10TH(firstarg, secondarg, thirdarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg, secondarg, thirdarg) REST_HELPER2(TWOORMORE, firstarg, secondarg, thirdarg) REST_HELPER_TWOORMORE(firstarg, secondarg, thirdarg) , secondarg, thirdarg 答案 1 :(得分：58)
如果您愿意接受可传递给可变参数宏的参数数量的某些硬编码上限，则可以避免使用GCC的,##__VA_ARGS__扩展名，如Richard Hansen's answer to this question中所述。但是，如果您不希望有任何此类限制，则据我所知，仅使用C99指定的预处理器功能是不可能的;你必须使用一些语言扩展。 clang和icc采用了这个GCC扩展，但MSVC没有。
早在2001年，我在document N976中编写了标准化的GCC扩展（以及允许您使用__VA_ARGS__以外的名称作为rest参数的相关扩展名），但没有得到回复委员会的任何内容;我甚至不知道是否有人读过它。 2016年再次在N2023中提出，我鼓励任何知道该提案如何在评论中告知我们的人。
答案 2 :(得分：15)
不是一般解决方案，但在printf的情况下，您可以附加一个换行符，如：
#define BAR_HELPER(fmt, ...) printf(fmt "\n%s", __VA_ARGS__)
#define BAR(...) BAR_HELPER(__VA_ARGS__, "")
我相信它会忽略格式字符串中未引用的任何额外args。所以你甚至可以逃脱：
#define BAR_HELPER(fmt, ...) printf(fmt "\n", __VA_ARGS__)
#define BAR(...) BAR_HELPER(__VA_ARGS__, 0)
我无法相信C99在没有标准方法的情况下获得批准。 AFAICT问题也存在于C ++ 11中。
答案 3 :(得分：10)
有一种方法可以使用像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
空宏参数列表实际上由一个恰好为空的参数组成。
在这种情况下，我们很幸运，因为您想要的宏总是至少有一个参数，我们可以将它实现为两个“重载”宏：
#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__) \
/**/
或
#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__)))) \
/**/
答案 4 :(得分：5)
我最近遇到了类似的问题，我相信有一个解决方案。
关键的想法是，有一种方法可以编写宏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的目标是扩展到另一个宏“呼叫”。
请注意，未使用NUM_ARGS本身。我只是把它包括在内来说明这里的基本技巧。请参阅Jens Gustedt's P99 blog以获得良好的治疗效果。
两个注释：
NUM_ARGS受限于它处理的参数数量。矿 最多只能处理20个，虽然数量完全是任意的。
如图所示，NUM_ARGS有一个陷阱，因为它在给定0个参数时返回1。它的要点是NUM_ARGS在技术上计算[逗号+ 1]，而不是args。在这 特殊情况，它实际上适用于我们的 优点。 _UNIMPLEMENTED1会处理一个空令牌就好了 它使我们不必编写_UNIMPLEMENTED0。 Gustedt有一个 虽然我没有使用它，但我不确定它是否适用于我们在这里做的事情。
答案 5 :(得分：4)
我用于调试打印的一个非常简单的宏：
#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。
答案 6 :(得分：2)
如果有c++11或以上版本，并且宏打算扩展为函数调用，你可以为它做一个包装器，例如：
#define BAR(fmt, ...) printf(fmt, __VA_ARGS__)
可以转换为
#define BAR(fmt, ...) BAR_wrapper(fmt)(__VA_ARGS__)
其中 BAR_wrapper 可以定义为：
struct BAR_wrapper_t {
BAR_wrapper_t(const char* fmt) : fmt(fmt) {}
const char* fmt;
int operator()() const { return printf(fmt); }
template <typename... Args>
int operator()(Args&& args) const { return printf(fmt, std::forward<Args>(args)...); }
};
inline BAR_wrapper_t BAR_wrapper(const char* fmt) { return BAR_wrapper_t(fmt); }
答案 7 :(得分：1)
这是我使用的简化版本。它基于其他答案的伟大技巧，给他们很多道具：
#define _SELECT(PREFIX,_5,_4,_3,_2,_1,SUFFIX,...) PREFIX ## _ ## SUFFIX
#define _BAR_1(fmt) printf(fmt "\n")
#define _BAR_N(fmt, ...) printf(fmt "\n", __VA_ARGS__);
#define BAR(...) _SELECT(_BAR,__VA_ARGS__,N,N,N,N,1)(__VA_ARGS__)
int main(int argc, char *argv[]) {
BAR("here is a log message");
BAR("here is a log message with a param: %d", 42);
return 0;
}
那就是它。
与其他解决方案一样，这仅限于宏的参数数量。要支持更多内容，请向_SELECT添加更多参数，并添加更多N个参数。参数名称倒计时（而不是up）以提醒基于计数的SUFFIX参数以相反的顺序提供。
此解决方案将0个参数视为1个参数。因此BAR()名义上＆＃34;工作＆＃34;，因为它扩展为_SELECT(_BAR,,N,N,N,N,1)()，扩展为_BAR_1()()，扩展为printf("\n")。
如果您愿意，可以使用_SELECT获得创意，并为不同数量的参数提供不同的宏。例如，这里我们有一个LOG宏，它采用了一个＆＃39;级别＆＃39;格式之前的参数。如果缺少格式，则记录＆＃34;（无消息）＆＃34;，如果只有1个参数，它将通过＆＃34;％s＆＃34;记录它，否则它将格式参数视为其余参数的printf格式字符串。
#define _LOG_1(lvl) printf("[%s] (no message)\n", #lvl)
#define _LOG_2(lvl,fmt) printf("[%s] %s\n", #lvl, fmt)
#define _LOG_N(lvl,fmt, ...) printf("[%s] " fmt "\n", #lvl, __VA_ARGS__)
#define LOG(...) _SELECT(_LOG,__VA_ARGS__,N,N,N,2,1)(__VA_ARGS__)
int main(int argc, char *argv[]) {
LOG(INFO);
LOG(DEBUG, "here is a log message");
LOG(WARN, "here is a log message with param: %d", 42);
return 0;
}
/* outputs:
[INFO] (no message)
[DEBUG] here is a log message
[WARN] here is a log message with param: 42
*/
答案 8 :(得分：0)
在您的情况下（至少存在1个参数，永不为0），您可以将BAR定义为BAR(...)，使用Jens Gustedt's HAS_COMMA(...)来检测逗号然后分派移至BAR0(Fmt)或BAR1(Fmt,...)。
此：
#define HAS_COMMA(...) HAS_COMMA_16__(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)
#define HAS_COMMA_16__(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
#define CAT_(X,Y) X##Y
#define CAT(X,Y) CAT_(X,Y)
#define BAR(.../*All*/) CAT(BAR,HAS_COMMA(__VA_ARGS__))(__VA_ARGS__)
#define BAR0(X) printf(X "\n")
#define BAR1(X,...) printf(X "\n",__VA_ARGS__)
#include <stdio.h>
int main()
{
BAR("here is a log message");
BAR("here is a log message with a param: %d", 42);
}
使用-pedantic进行编译，而不会发出警告。
答案 9 :(得分：0)
#define EMPTYFIRST(x,...) A x (B)
#define A(x) x()
#define B() ,
#define EMPTY(...) C(EMPTYFIRST(__VA_ARGS__) SINGLE(__VA_ARGS__))
#define C(...) D(__VA_ARGS__)
#define D(x,...) __VA_ARGS__
#define SINGLE(...) E(__VA_ARGS__, B)
#define E(x,y,...) C(y(),)
#define NONEMPTY(...) F(EMPTY(__VA_ARGS__) D, B)
#define F(...) G(__VA_ARGS__)
#define G(x,y,...) y()
#define STRINGIFY(...) STRINGIFY2(__VA_ARGS__)
#define STRINGIFY2(...) #__VA_ARGS__
#define BAR(fmt, ...) printf(fmt "\n" NONEMPTY(__VA_ARGS__) __VA_ARGS__)
int main() {
puts(STRINGIFY(NONEMPTY()));
puts(STRINGIFY(NONEMPTY(1)));
puts(STRINGIFY(NONEMPTY(,2)));
puts(STRINGIFY(NONEMPTY(1,2)));
BAR("here is a log message");
BAR("here is a log message with a param: %d", 42);
}
假设：
A〜G（可以重命名为hard_collide的对象）答案 10 :(得分：-2)
标准解决方案是使用FOO代替BAR。有一些奇怪的论证重新排序，它可能无法为你做（虽然我打赌有人可以根据其中的参数数量有条件地反汇编和重新组装__VA_ARGS__！）但是在一般使用FOO“通常”只是工作。