blocks|key|218959|text|就所发生的一切而言，这是绝对没有意义的，这就是重点。只是对变量的引用，但对它绝对不做任何操作。编译器尽职尽责地处理它，注意到使用了该参数，然后抛出所有内容，而不生成任何实际代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|218960|就括号而言：|218961|对可能在表达式中使用的宏使用括号是一种很好的做法，即使在不需要它时也是如此。|218962|例如，假设代码中有一个简单的宏，它在屏幕上绘制窗口。这样做的库在窗口周围添加了一个边框，比如说，它有6个像素长。此宏计算窗口的总宽度。这个宏的简单实现如下：|218963|#define+ACTUAL_WIDTH(w)++w%2B6|code-block|syntax|javascript|218964|现在，假设您的代码想要计算两个窗口的实际宽度。这两个窗口都有100个像素宽：|218965|int+total_width=ACTUAL_WIDTH(100)*2;|218966|你觉得会发生什么？回想一下，宏替换基本上只是一个简单的文本替换，所以这就是实际编译的内容：|218967|int+total_width=100%2B6*2;|218968|这是完全错误的。您希望在宏中有一组额外的括号，以便编译正确的代码：|218969|int+total_width=(100%2B6)*2;|218970|这就是为什么在宏中经常会看到一组额外的括号，这些括号可以在表达式中使用。不仅如此，这样的宏还会在其参数周围加上括号，因此很可能是：|218971|#define+ACTUAL_WIDTH(w)++((w)%2B6)|218972|这就是为什么在宏中看到一组额外的括号。更容易养成一种习惯，就是总是把它们塞进你写的每一个宏中，并且是安全的；而不是每次都浪费时间去弄清楚是否真的需要它们。|218973|使用良好的编程习惯可以避免许多常见的错误。|218974|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1E|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|J|7|1I|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|1K|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1M|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

As far as what happens, it's absolutely nothing, and that's the point. Just a reference to the variable, but do absolutely nothing with it. The compiler dutifully processes it, notes that the parameter was used, then throws everything away and does not generate any actual code.

As far as parenthesis go:

It is a good practice to use parenthesis for macros that can potentially be used in an expression, even when it is not needed.

Consider, for example, a simple macro in hypothetical code that draws a window on the screen. The library that does it adds a border around the window that, say, is 6 pixels long. This macro computes the total width of the window. A naive implementation of this macro would read:

<pre><code>#define ACTUAL_WIDTH(w) w+6
</code></pre>

Now, let's say your code wants to compute the actual width of two windows. Both windows are 100 pixels wide:

<pre><code>int total_width=ACTUAL_WIDTH(100)*2;
</code></pre>

What do you think happens? Recall that a macro substitution is basically just a straightforward text substitution, so this is what actually gets compiled:

<pre><code>int total_width=100+6*2;
</code></pre>

Which is utterly wrong. You want to have an extra set of parenthesis in your macro, so that the correct code gets compiled:

<pre><code>int total_width=(100+6)*2;
</code></pre>

And that's why you will often see an extra set of parenthesis in macros that can be used in expressions. Not only that, a macro like that will also have parenthesis around its argument, so it will probably be:

<pre><code>#define ACTUAL_WIDTH(w) ((w)+6)
</code></pre>

And that's why you see an extra set of parenthesis in macros. It's easier to acquire a habit of always sticking them into every macro you write and be safe; rather than waste time figuring out, every time, if they are really needed or not.

Using good programming habits will avoid many common bugs.

blocks|key|219000|text|正如您所说的，您的代码不会显示未使用的变量警告，因为您使用的是变量'x‘，但是您只是不对它做任何事情，而是将它传递给一个没有什么重要操作的函数(NOOP(x)+-做什么都不重要，但是编译器看到您正在尝试使用x变量)，所以它不会告诉您您没有使用变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|219001|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

As you said , your code will not display a unused variable warning because you are using your variable 'x' , but you are just doing nothing to it , you are passing it to a function that do nothing important (NOOP(x) --do nothing important but , compiler see you are trying to use the x variable) so it do not tell you you are not using your variable

blocks|key|219050|text|取自2014年11月C%2B%2B14标准工作草案第5.2.9节第6段|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|219051|任何表达式都可以显式转换为cv类型，在这种情况下，它会变成一个废弃的值表达式。|blockquote|219052|正如其他人所指出的，额外的括号有效地隔离了表达式周围的代码，从而禁止了任何不想要的效果。虽然在这种情况下，我认为在实际应用中不包括外括号是不太可能产生任何不良影响的，特别是如果您只是使用它来避免函数中未使用的变量警告。不过，把它们排除在外并不值得冒任何风险。|219053|为了演示这一点，我提出了一个非常精心设计的示例，它导致了代码的无意执行，因为有些操作符的优先级比C风格的转换要高。|219054|#include+<iostream>

#define+NOOP(x)+((void)(x))
#define+MYNOOP(x)+(void)+(x)

struct+A
{
++bool+operator()(void)+{
++++std::cout+<<+"Called+function+unintentionally"+<<+std::endl;
++++return+true;
++}
};

int+main()+{
++A+i;
++MYNOOP(i)();
++//NOOP(i)();+//+error:+called+object+type+'void'+is+not+a+function+or+function+pointer
++return+0;
}|code-block|syntax|javascript|219055|entityMap|0|LINK|mutability|MUTABLE|url|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4296.pdf^0|2|J|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|14|8|@]|9|@]|C|$N|O]]|$1|P|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

From Section 5.2.9 paragraph 6 of the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4296.pdf" rel="nofollow">C++14 standard working draft from November 2014</a>:

<blockquote>
 Any expression can be explicitly converted to type cv void, in which case it becomes a discarded-value expression.
</blockquote>

As stated by others, the extra parentheses prohibits any undesired effects by effectively quarantining the expression from code that might be around it. Although in this case, I believe it would be unlikely that any ill effects would be felt in practical applications by not including the outer parentheses, especially if you were just using this to avoid the unused variable warning in a function. It is just not worth any risk though by leaving them out.

To demonstrate this, I have come up with a very contrived example that leads to unintentional execution of code, because there are operators with higher precedence than C-style casting.

<pre><code>#include &lt;iostream&gt;

#define NOOP(x) ((void)(x))
#define MYNOOP(x) (void) (x)

struct A
{
 bool operator()(void) {
 std::cout &lt;&lt; "Called function unintentionally" &lt;&lt; std::endl;
 return true;
 }
};

int main() {
 A i;
 MYNOOP(i)();
 //NOOP(i)(); // error: called object type 'void' is not a function or function pointer
 return 0;
}
</code></pre>

Hoping to get some clarification/explaination on the following piece of code

<pre><code>#define NOOP(x) ((void)(x))

void my_function(int x)
{
 NOOP(x);
}
</code></pre>

This macro prevents unused parameter warnings.

I have two questions-

<ol>
<li>So we're void casting whatever x is by using this macro. What's
really happening when we void cast something?</li>
<li>Why the extra set of parenthesis around <code>(void)(x)</code></li>
</ol>

Thanks

Void cast macro explaination

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

希望能对下面的代码得到一些澄清/解释#define NOOP(x) ((void)(x))void my_function(int x){     NOOP(x);}此宏防止未使用的参数警告。我有两个问题-所以我们用这个宏来消除任何x。当我们虚空抛出什么东西时，到底发生了什么？为什么(void)(x)周围有额外的括号谢...

问空铸宏解释
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问空铸宏解释EN