【问题标题】：Standard alternative to GCC's ##__VA_ARGS__ trick?GCC ##__VA_ARGS__ 技巧的标准替代方案？
【发布时间】：2011-08-01 02:59:28
【问题描述】：

在 C99 中有一个 well-known problem 带有空参数，用于可变参数宏。

示例：

#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() 打印，如果日志记录是行缓冲的并且来自多个异步源，这将是有利的。

【问题讨论】：

为什么首先使用BAR 而不是FOO？
@GMan：我在最后加了一个例子
@GMan：阅读最后一句话（：
C2x 中的此功能 has been proposed for inclusion。
@zwol 提交给 WG14 looks like this 的最新版本，它使用基于 __VA_OPT__ 关键字的新语法。这是 C++ 的 has already been "adopted"，所以我希望 C 会效仿。（不知道这是否意味着它被快速跟踪到 C++17 或者它是否设置为 C++20）

标签： c c99 c-preprocessor variadic-macros

【解决方案1】：

如果您愿意接受一些硬编码的参数上限，则可以避免使用 GCC 的 ,##__VA_ARGS__ 扩展，可以传递给可变参数宏的参数数量，如 Richard Hansen's answer to this question 中所述。但是，如果您不希望有任何此类限制，据我所知，仅使用 C99 指定的预处理器功能是不可能的；您必须使用该语言的一些扩展。 clang 和 icc 采用了这个 GCC 扩展，但 MSVC 没有。

早在 2001 年，我就在 document N976 中编写了用于标准化的 GCC 扩展（以及允许您使用 __VA_ARGS__ 以外的名称作为其余参数的相关扩展），但委员会没有收到任何回应;我什至不知道有没有人读过。 2016 年，它再次在 N2023 中提出，我鼓励任何知道该提案将如何在 cmets 中告诉我们的人。

【讨论】：

从我无法在网上找到解决方案和这里没有答案的情况来看，我猜你是对的）：
你指的是n976吗？我搜索了C working group 的documents 的其余部分以获取回复，但从未找到。它甚至不在agenda for the subsequent meeting 中。关于这个话题的唯一其他热门是挪威在 C99 被批准之前在n868 中的评论#4（同样没有后续讨论）。
是的，特别是后半部分。 comp.std.c 上可能有讨论，但我刚才在 Google Groups 中找不到任何内容；它当然从来没有得到实际委员会的任何关注（或者即使有，也没有人告诉过我）。
恐怕我没有证据，也不再是想出一个想法的合适人选。我确实写了一半的 GCC 预处理器，但那是十多年前的事了，即使在那时，我也从未想过下面的参数计数技巧。
此扩展适用于 clang & intel icc 编译器以及 gcc。

【解决方案2】：

标准解决方案是使用FOO 而不是BAR。有一些奇怪的参数重新排序案例可能无法为您做（尽管我敢打赌，有人可以根据其中的参数数量有条件地提出巧妙的技巧来分解和重新组装__VA_ARGS__！）但通常使用FOO“通常”就可以了。

【讨论】：

问题是“是否有符合标准的方法来获得这种行为？”
这个问题已经包含了一个现在不使用 FOO 的理由。

【解决方案3】：

不是一般的解决方案，但在 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 这个问题也存在于 C++11 中。

【讨论】：

这个额外的 0 的问题是，如果它调用 vararg 函数，它实际上最终会出现在代码中。检查 Richard Hansen 提供的解决方案
@Pavel 关于第二个示例是正确的，但第一个示例效果很好。 +1。

【解决方案4】：

我最近遇到了类似的问题，我相信有解决方案。

关键思想是有一种方法可以编写一个宏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 在技术上计数 [commas + 1]，而不是 args。在这个在特殊情况下，它实际上适用于我们优势。 _UNIMPLEMENTED1 将处理一个空令牌就好了它使我们不必编写_UNIMPLEMENTED0。古斯特有一个解决方法也是如此，虽然我没有使用它，我不确定它是否适用于我们在这里所做的工作。

【讨论】：

+1 用于提出论据计数技巧，-1 用于非常难以理解
您添加的 cmets 是一个改进，但仍然存在许多问题： 1. 您讨论并定义了 NUM_ARGS 但不使用它。 2、UNIMPLEMENTED的用途是什么？ 3. 你从来没有解决问题中的示例问题。 4. 一步一步地浏览扩展将说明它是如何工作的，并解释每个辅助宏的作用。 5. 讨论 0 个论点让人分心； OP 询问标准合规性，并且禁止使用 0 个参数（C99 6.10.3p4）。 6. 步骤 1.5？为什么不是第 2 步？ 7.“步骤”意味着按顺序发生的动作；这只是代码。
8.您链接到整个博客，而不是相关帖子。我找不到你说的那个帖子。 9.最后一段很别扭：这个方法是晦涩的；这就是为什么之前没有其他人发布过正确解决方案的原因。此外，如果它有效并且符合标准，那么 Zack 的回答一定是错误的。 10. 你应该定义CONCAT()——不要假设读者知道它是如何工作的。
（请不要将此反馈解释为攻击——我真的很想对您的答案表示赞同，但除非它更易于理解，否则我觉得这样做不太舒服。如果您可以改进你的答案清晰，我会支持你的并删除我的。）
我绝对不会想到这种方法，而且我编写了大约一半的 GCC 当前预处理器！也就是说，我仍然会说“没有标准的方法来获得这种效果”，因为您和 Richard 的技术都对宏的参数数量施加了上限。

【解决方案5】：

您可以使用一个参数计数技巧。

这是在 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__ 分隔为第一个参数和其余参数（如果有）。这样就可以在第一个参数之后但第二个（如果存在）之前插入内容。

`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 个参数）。

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

【讨论】：

请注意，如果您使用 10 个或更多参数调用 BAR，这将失败，虽然它相对容易扩展到更多参数，但它总是有它可以处理的参数数量的上限
@ChrisDodd：正确。不幸的是，似乎没有办法在不依赖编译器特定扩展的情况下避免参数数量的限制。另外，我不知道有一种方法可以可靠地测试是否有太多参数（以便可以打印有用的编译器错误消息，而不是奇怪的失败）。
不幸的是，它只适用于字符串参数！ BAR("val:%d", 1);编译失败！

【解决方案6】：

有一种方法可以使用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__) \
    /**/

或

#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__)))) \
    /**/

【讨论】：

很高兴了解 Boost.Preprocessor，+1。请注意，BOOST_PP_VARIADIC_SIZE() 使用了我在回答中记录的相同参数计数技巧，并且具有相同的限制（如果您传递超过一定数量的参数，它将中断）。
是的，我看到您的方法与 Boost 使用的方法相同，但 boost 解决方案维护得很好，并且在开发更复杂的宏时还有许多其他非常有用的功能。递归的东西特别酷（并且在使用 BOOST_PP_ARRAY_ENUM 的最后一种方法中在幕后使用）。
一个实际适用于c 标签的 Boost 答案！万岁！

【解决方案7】：

这是我使用的简化版本。它基于此处其他答案的出色技术，因此有很多道具：

#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 参数。参数名称倒数（而不是向上）以提醒您以相反的顺序提供基于计数的 SUFFIX 参数。

此解决方案将 0 个参数视为 1 个参数。所以BAR()名义上是“有效的”，因为它扩展为_SELECT(_BAR,,N,N,N,N,1)()，它扩展为_BAR_1()()，它扩展为printf("\n")。

如果您愿意，您可以使用_SELECT 获得创意，并为不同数量的参数提供不同的宏。例如，这里我们有一个 LOG 宏，它在格式之前接受一个“级别”参数。如果缺少格式，则记录“（无消息）”，如果只有 1 个参数，则通过“%s”记录，否则将格式参数视为 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
*/

【讨论】：

使用 -pedantic 编译时仍然会触发警告。

【解决方案8】：

在您的情况下（至少存在 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】：

我用于调试打印的一个非常简单的宏：

#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。

【讨论】：

关于此代码的一个小警告，如所写：__DBG_INT 中的双下划线被认为会导致“未定义行为”。这是不太可能引起问题的事情，但是在从头开始编写或重构时了解一下是很好的——在这种情况下很容易选择不同的约定，例如DBG_INT_ 或DBG__INT。跨度>
C11 标准 (N1570) 中的相关 sn-ps，7.1.3 保留标识符：“1. 以下划线和大写字母或另一个下划线开头的所有标识符始终保留用于任何用途。” "2. 没有其他标识符被保留。如果程序在保留标识符的上下文中声明或定义标识符（7.1.4 允许的除外），或将保留标识符定义为宏名称，则行为未定义。” （注意：这也排除了 _DBG_INT 之类的内容。）
不知道，谢谢。对于 C99，它是否也被视为未定义行为？
不客气；我希望它有所帮助。是的，它也是 C99 中的 UB。它与 C99/N1256 中的相同部分（7.1.3，p1 和 p2）。祝你好运！

【解决方案10】：

C (gcc)，762 字节

#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);
}

Try it online!

假设：

没有 arg 包含逗号或括号
没有arg包含A~G（可以重命名为hard_collide）

【讨论】：

no arg contain comma 的限制可以通过在多次通过后检查 multi 来绕过，但 no bracket 仍然存在

【解决方案11】：

如果 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); }

【讨论】：

【解决方案12】：

如果您使用gcc 8+、clang 6+ 或MSVC 2019 (source)，那么您也可以使用（较新的）__VA_OPT__ 宏，如果__VA_ARGS__ 不为空，则该宏有条件地扩展。

所以，我们可以将FOO 和BAR 这两个宏合二为一：

#define FOO(s, ...) printf(FOO __VA_OPT__(,) __VA_ARGS__)

因此，FOO("hello!") 将扩展为 printf("hello!")，FOO("x = %d", 5) 将扩展为 printf("x = %d", 5)。

这是一个相对较新的功能（在 C++2a 中引入），因此您的编译器可能还不支持它。

【讨论】：