blocks|key|3958954|text|如果您的预处理器支持各种宏：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3958955|#define+SINGLE_ARG(...)+__VA_ARGS__
#define+FOO(type,name)+type+name

FOO(SINGLE_ARG(std::map<int,+int>),+map_var);|code-block|syntax|javascript|3958956|否则，它会更加单调乏味：|3958957|#define+SINGLE_ARG2(A,B)+A,B
#define+SINGLE_ARG3(A,B,C)+A,B,C
//+as+many+as+you'll+need

FOO(SINGLE_ARG2(std::map<int,+int>),+map_var);|3958958|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If your preprocessor supports variadic macros:

<pre><code>#define SINGLE_ARG(...) __VA_ARGS__
#define FOO(type,name) type name

FOO(SINGLE_ARG(std::map&lt;int, int&gt;), map_var);
</code></pre>

Otherwise, it's a bit more tedious:

<pre><code>#define SINGLE_ARG2(A,B) A,B
#define SINGLE_ARG3(A,B,C) A,B,C
// as many as you'll need

FOO(SINGLE_ARG2(std::map&lt;int, int&gt;), map_var);
</code></pre>

blocks|key|3958995|text|至少有两种方法可以做到这一点。首先，您可以定义一个接受多个参数的宏：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3958996|#define+FOO2(type1,+type2,+name)+type1,+type2,+name|code-block|syntax|javascript|3958997|如果你这样做了，你可能会发现你最终会定义更多的宏来处理更多的参数。|3958998|其次，您可以用括号将参数括起来：|3958999|#define+FOO(type,+name)+type+name
F00((std::map<int,+int>)+map_var;|3959000|如果你这样做，你可能会发现额外的圆括号搞乱了结果的语法。|3959001|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

There are at least two ways to do this. First, you can define a macro that takes multiple arguments:

<pre><code>#define FOO2(type1, type2, name) type1, type2, name
</code></pre>

if you do that you may find that you end up defining more macros to handle more arguments.

Second, you can put parentheses around the argument:

<pre><code>#define FOO(type, name) type name
F00((std::map&lt;int, int&gt;) map_var;
</code></pre>

if you do that you may find that the extra parentheses screw up the syntax of the result.

blocks|key|610321|text|答案很简单:不能。这是选择<...>作为模板参数的副作用；<和>也出现在不平衡的上下文中，所以宏机制不能像处理括号那样对它们进行扩展。(一些委员会成员曾主张使用不同的标记，例如(%5E...%5E)，但他们无法使用<...>说服大多数问题。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|610322|entityMap^0|D|5|T|1|V|1|2G|7|2V|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

The simple answer is that you can't. This is a side effect of the choice of <code>&lt;...&gt;</code> for template arguments; the <code>&lt;</code> and <code>&gt;</code> also appear in unbalanced contexts so the macro mechanism couldn't be extended to handle them like it handles parentheses. (Some of the committee members had argued for a different token, say <code>(^...^)</code>, but they weren't able to convince the majority of the problems using <code>&lt;...&gt;</code>.)

blocks|key|69229|text|由于尖括号也可以表示(或出现在)比较运算符<、>、<=和>=中，因此宏扩展不能像在圆括号中那样忽略尖括号中的逗号。(这对于方括号和大括号也是一个问题，即使它们通常作为平衡对出现。)您可以将宏参数括在括号中：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|69230|FOO((std::map<int,+int>),+map_var);|code-block|syntax|javascript|69231|然后，问题是参数在宏展开式中仍然是用括号括起来的，这阻止了它在大多数上下文中被读取为一个类型。|69232|解决这个问题的一个很好的技巧是，在C%2B%2B中，您可以使用函数类型从带括号的类型名中提取typename：|69233|template<typename+T>+struct+argument_type;
template<typename+T,+typename+U>+struct+argument_type<T(U)>+{+typedef+U+type;+};
#define+FOO(t,name)+argument_type<void(t)>::type+name
FOO((std::map<int,+int>),+map_var);|69234|由于形成函数类型会忽略额外的圆括号，因此可以在类型名称不包含逗号的情况下使用带括号或不带括号的此宏：|69235|FOO((int),+int_var);
FOO(int,+int_var2);|69236|当然，在C中，这不是必需的，因为类型名称不能包含括号内的逗号。因此，对于跨语言的宏来说，你可以这样写：|69237|#ifdef+__cplusplus__
template<typename+T>+struct+argument_type;
template<typename+T,+typename+U>+struct+argument_type<T(U)>+{+typedef+U+type;+};
#define+FOO(t,name)+argument_type<void(t)>::type+name
#else
#define+FOO(t,name)+t+name
#endif|69238|entityMap^0|L|1|N|1|P|2|S|2|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1F|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|Y|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|Z|$]]

Because angle brackets can also represent (or occur in) the comparison operators <code>&lt;</code>, <code>&gt;</code>, <code>&lt;=</code> and <code>&gt;=</code>, macro expansion can't ignore commas inside angle brackets like it does within parentheses. (This is also a problem for square brackets and braces, even though those usually occur as balanced pairs.) You can enclose the macro argument in parentheses:

<pre><code>FOO((std::map&lt;int, int&gt;), map_var);
</code></pre>

The problem is then that the parameter remains parenthesized inside the macro expansion, which prevents it being read as a type in most contexts.

A nice trick to workaround this is that in C++, you can extract a typename from a parenthesized type name using a function type:

<pre><code>template&lt;typename T&gt; struct argument_type;
template&lt;typename T, typename U&gt; struct argument_type&lt;T(U)&gt; { typedef U type; };
#define FOO(t,name) argument_type&lt;void(t)&gt;::type name
FOO((std::map&lt;int, int&gt;), map_var);
</code></pre>

Because forming function types ignores extra parentheses, you can use this macro with or without parentheses where the type name doesn't include a comma:

<pre><code>FOO((int), int_var);
FOO(int, int_var2);
</code></pre>

In C, of course, this isn't necessary because type names can't contain commas outside parentheses. So, for a cross-language macro you can write:

<pre><code>#ifdef __cplusplus__
template&lt;typename T&gt; struct argument_type;
template&lt;typename T, typename U&gt; struct argument_type&lt;T(U)&gt; { typedef U type; };
#define FOO(t,name) argument_type&lt;void(t)&gt;::type name
#else
#define FOO(t,name) t name
#endif
</code></pre>

blocks|key|3959125|text|使用P99可以做到这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3959126|#include+"p99/p99.h"
#define+FOO(...)+P99_ALLBUTLAST(__VA_ARGS__)+P99_LAST(__VA_ARGS__)
FOO()|code-block|syntax|javascript|3959127|上面的代码实际上只删除了参数列表中的最后一个逗号。请咨询clang+-E+(P99需要C99编译器)。|style|CODE|3959128|entityMap|0|LINK|mutability|MUTABLE|url|http://p99.gforge.inria.fr/^0|2|3|0|0|0|S|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

This is possible with <a href="http://p99.gforge.inria.fr/" rel="nofollow">P99</a>:

<pre><code>#include "p99/p99.h"
#define FOO(...) P99_ALLBUTLAST(__VA_ARGS__) P99_LAST(__VA_ARGS__)
FOO()
</code></pre>

The code above effectively strips only the last comma in the argument list. Check with <code>clang -E</code> (P99 requires a C99 compiler).

blocks|key|4440468|text|如果您不能使用括号，并且您不喜欢Mike的SINGLE_ARG解决方案，那么只需定义一个逗号：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4440469|#define+COMMA+,

FOO(std::map<int+COMMA+int>,+map_var);|code-block|syntax|javascript|4440470|如果您想将一些宏参数串行化，这也很有帮助，如|4440471|#include+<cstdio>
#include+<map>
#include+<typeinfo>

#define+STRV(...)+#__VA_ARGS__
#define+COMMA+,
#define+FOO(type,+bar)+bar(STRV(type)+\
++++"+has+typeid+name+\"%25s\"",+typeid(type).name())

int+main()
{
++++FOO(std::map<int+COMMA+int>,+std::printf);
}|4440472|它打印std::map<int+,+int>+has+typeid+name+"St3mapIiiSt4lessIiESaISt4pairIKiiEEE"。|offset|length|style|CODE|4440473|entityMap^0|0|0|0|0|3|22|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

If you can't use parentheses and you don't like Mike's SINGLE_ARG solution, just define a COMMA:

<pre><code>#define COMMA ,

FOO(std::map&lt;int COMMA int&gt;, map_var);
</code></pre>

This also helps if you want to stringify some of the macro arguments, as in

<pre><code>#include &lt;cstdio&gt;
#include &lt;map&gt;
#include &lt;typeinfo&gt;

#define STRV(...) #__VA_ARGS__
#define COMMA ,
#define FOO(type, bar) bar(STRV(type) \
 " has typeid name \"%s\"", typeid(type).name())

int main()
{
 FOO(std::map&lt;int COMMA int&gt;, std::printf);
}
</code></pre>

which prints <code>std::map&lt;int , int&gt; has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE"</code>.

blocks|key|4440495|text|将FOO定义为|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4440496|#define+UNPACK(+...+)+__VA_ARGS__

#define+FOO(+type,+name+)+UNPACK+type+name|code-block|syntax|javascript|4440497|然后总是用括号将类型参数括起来调用它，例如|4440498|FOO(+(std::map<int,+int>),+map_var+);|4440499|当然，在宏定义的注释中举例说明调用是一个好主意。|4440500|entityMap^0|1|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

Just define <code>FOO</code> as

<pre><code>#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name
</code></pre>

Then invoke it always with parenthesis around the type argument, e.g.

<pre><code>FOO( (std::map&lt;int, int&gt;), map_var );
</code></pre>

It can of course be a good idea to exemplify the invocations in a comment on the macro definition.

Say we have a macro like this 

<pre><code>#define FOO(type,name) type name
</code></pre>

Which we could use like

<pre><code>FOO(int, int_var);
</code></pre>

But not always as simply as that:

<pre><code>FOO(std::map&lt;int, int&gt;, map_var); // error: macro "FOO" passed 3 arguments, but takes just 2
</code></pre>

Of course we could do:

<pre><code> typedef std::map&lt;int, int&gt; map_int_int_t;
 FOO(map_int_int_t, map_var); // OK
</code></pre>

which is not very ergonomic. Plus type incompatibilities have to be dealt with. Any idea how to resolve this with macro ?

Comma in C/C++ macro

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设我们有一个这样的宏#define FOO(type,name) type name我们可以像这样使用FOO(int, int_var);但并不总是如此简单：FOO(std::map<int, int>, map_var); // error: macro "FOO" passed 3 arguments, but ...

问C/C++宏中的逗号
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++宏中的逗号EN