blocks|key|1647|text|预处理器应该正确地用括号括起来。将其替换为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1648|#define+CUBE(p)+((p)*(p)*(p))|code-block|syntax|javascript|1649|然后你看。|1650|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Preprocessors should be parenthesized properly. Replace it with

<pre><code>#define CUBE(p) ((p)*(p)*(p))
</code></pre>

and see.

blocks|key|966685|text|预处理器仅替换为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966686|CUBE(3)|code-block|syntax|javascript|966687|使用|966688|3*3*3|966689|所以你最终会得到：|966690|k=27/3*3*3|966691|从左到右按运算符优先级计算，实际上是81。|966692|如果在宏两边添加括号，您会发现结果是正确的：|966693|#define+CUBE(p)+(p*p*p)|966694|更好的做法是用括号将每个p实例括起来，如：|offset|length|style|CODE|966695|#define+CUBE(p)+((p)*(p)*(p))|966696|这将允许您将表达式正确地传递给宏(例如，1+%2B+2)。|966697|entityMap^0|0|0|0|0|0|0|0|0|0|C|1|0|0|K|5|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1F|8|@$W|1G|X|1H|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|1J|8|@$W|1K|X|1L|Y|Z]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|15|$]]

The preprocessor merely substitutes

<pre><code>CUBE(3)
</code></pre>

with

<pre><code>3*3*3
</code></pre>

So you end up with:

<pre><code>k=27/3*3*3
</code></pre>

Which, evaluated left-to-right with operator precedence, is in fact 81.

If you add parenthesees around the macro, you should find the results are correct:

<pre><code>#define CUBE(p) (p*p*p)
</code></pre>

It would be even better to surround each instance of <code>p</code> with parenthesees as well, as in:

<pre><code>#define CUBE(p) ((p)*(p)*(p))
</code></pre>

Which will allow you to pass expressions to the macro correctly (for example, <code>1 + 2</code>).

blocks|key|749400|text|由于运算符优先级而导致的+27/3*3*3+=+81|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|749401|您可以使用：|749402|inline+int+cube(int+p)+{+return+p*p*p;+}|code-block|syntax|javascript|749403|entityMap^0|D|D|D|D|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|U|8|@]|E|@]|F|$]]|$1|I|3|J|5|K|7|V|8|@]|E|@]|F|$L|M]]|$1|N|3|-4|5|6|7|W|8|@]|E|@]|F|$]]]|O|$]]

Because of operator precedence <code>27/3*3*3 = 81</code>

You could use instead:

<pre><code>inline int cube(int p) { return p*p*p; }
</code></pre>

blocks|key|749353|text|C宏会进行文本替换(例如，它等同于复制和粘贴代码)。所以你的代码是这样写的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|749354|k=27/CUBE(3);|code-block|syntax|javascript|749355|至|749356|k=27/3*3*3;|749357|除法和乘法具有相同的优先级，并且具有从左到右的结合性，因此它被解析为：|749358|k=((27/3)*3)*3;|749359|即9*3*3=+81。|749360|这就是为什么C语言的宏应该总是使用括号定义的原因：|749361|#define+CUBE(p)+((p)+*+(p)+*+(p))|749362|有关更多信息，请参阅comp.lang.c常见问题解答中的http://c-faq.com/cpp/safemacros.html。|offset|length|749363|entityMap|0|LINK|mutability|MUTABLE|url|http://c-faq.com/cpp/safemacros.html^0|0|0|0|0|0|0|0|0|0|T|10|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1F|8|@]|9|@$W|1G|X|1H|1|1I]]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

C macros do textual substitution (i.e. it's equivalent to copying and pasting code). So your code goes from:

<pre><code>k=27/CUBE(3);
</code></pre>

to

<pre><code>k=27/3*3*3;
</code></pre>

Division and multiplication have the same precedence and have left-to-right associativity, so this is parsed as:

<pre><code>k=((27/3)*3)*3;
</code></pre>

which is 9 * 3 * 3 = 81.

This is why C macros should always be defined with liberal use of parentheses:

<pre><code>#define CUBE(p) ((p) * (p) * (p))
</code></pre>

For more information, see <a href="http://c-faq.com/cpp/safemacros.html" rel="nofollow noreferrer">http://c-faq.com/cpp/safemacros.html</a> from the comp.lang.c FAQ.

blocks|key|749963|text|因为宏是一种文本替换，所以结果是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|749964|k+=+27+/+3+*+3+*+3;|code-block|syntax|javascript|749965|由于乘法和除法是从左到右进行的，因此计算结果为：|749966|k+=+((27+/+3)+*+3)+*+3;|749967|因此，您希望通过两种方式进行更改：|749968|#define+CUBE(p)+((p)*(p)*(p))|749969|外部圆括号使乘法运算在任何其他运算之前完成。|749970|单个p周围的圆括号用于执行以下操作的情况：|749971|CUBE(1+%2B+2);|749972|如果没有这些内部括号，运算符优先级将会使您陷入困境。|749973|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Because macros are a textual substitution, that works out to:

<pre><code>k = 27 / 3 * 3 * 3;
</code></pre>

Since multiplication and division happen left to right, that works out to:

<pre><code>k = ((27 / 3) * 3) * 3;
</code></pre>

So, you want to change that in two ways:

<pre><code>#define CUBE(p) ((p)*(p)*(p))
</code></pre>

The outer parentheses cause the multiplications to be done before any other operations.

The parentheses around the individual p's are for the case where you do:

<pre><code>CUBE(1 + 2);
</code></pre>

Without those inner parentheses, operator precedence will trip you up.

blocks|key|966825|text|您的宏不受保护。试一试|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966826|#define+CUBE(p)+((p)*(p)*(p))|code-block|syntax|javascript|966827|当前宏已展开为|966828|k=27/3*3*3|966829|即((27/3)*3)*3|966830|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Your macro is not protected. Try 

<pre><code>#define CUBE(p) ((p)*(p)*(p))
</code></pre>

The current macro was expanded to

<pre><code>k=27/3*3*3
</code></pre>

which is ((27/3)*3)*3

blocks|key|749274|text|+++++#define+CUBE(p)+p*p*p
+++++main()
+++++{
++++++++int+k;
++++++++k=27/CUBE(3);
++++++++printf("%25d",k);

+++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|749275|unstyled|749276|根据我的理解和知识，K的值应该是1，因为在预处理过程中立方体(3)会被3*3*3替换|blockquote|749277|749278|749279|是|749280|749281|，在随后的编译之后，它会给出1的值，但它显示的值是81，这让我很好奇它是如何发生的。|749282|749283|749284|不，|749285|k=+27/3*3*3+

+=(((27/3)*3)*3)+(The+precedence+of+`*`+and+`/`+are+same+but+the+associativity+is+from+left+to+right)
+=((9*3)*3)+=81|749286|用#define+CUBE(p)+((p)*(p)*(p))替换#define+CUBE(p)+p*p*p|offset|length|style|CODE|749287|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|1|T|W|L|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|A|$]]|$1|I|3|-4|5|E|7|16|8|@]|9|@]|A|$]]|$1|J|3|-4|5|E|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|E|7|18|8|@]|9|@]|A|$]]|$1|M|3|-4|5|E|7|19|8|@]|9|@]|A|$]]|$1|N|3|O|5|H|7|1A|8|@]|9|@]|A|$]]|$1|P|3|-4|5|E|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|E|7|1C|8|@]|9|@]|A|$]]|$1|R|3|S|5|E|7|1D|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1E|8|@]|9|@]|A|$B|C]]|$1|V|3|W|5|E|7|1F|8|@$X|1G|Y|1H|Z|10]|$X|1I|Y|1J|Z|10]]|9|@]|A|$]]|$1|11|3|-4|5|E|7|1K|8|@]|9|@]|A|$]]]|12|$]]

<pre><code> #define CUBE(p) p*p*p
 main()
 {
 int k;
 k=27/CUBE(3);
 printf("%d",k);

 }
</code></pre>

<blockquote>
 As per my understanding and knowledge the value of K should be 1 as CUBE(3) would be replaced by 3*3*3 during preprocessing 
</blockquote>

YES

<blockquote>
 and after the subsequent compilation it would be giving the value of 1,but instead it has shown the value of 81 which has made me curious to know how it happenned.
</blockquote>

NO, 

<pre><code>k= 27/3*3*3 

 =(((27/3)*3)*3) (The precedence of `*` and `/` are same but the associativity is from left to right)
 =((9*3)*3) =81
</code></pre>

Replace <code>#define CUBE(p) p*p*p</code> with <code>#define CUBE(p) ((p)*(p)*(p))</code>

blocks|key|966857|text|k=27/CUBE(3);++=>+++k=27/3+*+3+*+3;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|966858|你看到了吗？多维数据集应该像这样定义：|unstyled|966859|#define+CUBE(p)+((p)*(p)*(p))|966860|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>k=27/CUBE(3); =&gt; k=27/3 * 3 * 3;
</code></pre>

Do you see it? CUBE should be defined like this instead:

<pre><code>#define CUBE(p) ((p)*(p)*(p))
</code></pre>

blocks|key|2375883|text|在执行宏时，必须注意如何放置括号。在本例中，您没有任何值，因此表达式变成了27/3*3*3，根据/和*的优先规则，它变成了(27/3)*3*3。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2375884|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|$]]

When you do macros, you have to be careful about how you place parentheses. In this case, you don't have any, so the expression becomes 27/3*3*3, which by the precedence rules of / and * becomes (27/3)*3*3.

blocks|key|966940|text|27/3*3*3+=+9*3*3+=+81？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966941|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|$]]

blocks|key|967007|text|/和*操作符具有相同的优先级。要先执行3*3*3，您应该将它们括在括号中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|967008|#include+<stdio.h>

#define+CUBE(p)+p*p*p

int
main+()
{
++int+k;
++k=27/(CUBE(3));
++printf("%25d",k);
++return+0;
}|code-block|syntax|javascript|967009|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Both / and * operators have the same precedence. To execure 3*3*3 first, you shoudl enclose them in parenthesis.

<pre><code>#include &lt;stdio.h&gt;

#define CUBE(p) p*p*p

int
main ()
{
 int k;
 k=27/(CUBE(3));
 printf("%d",k);
 return 0;
}
</code></pre>

blocks|key|749422|text|它是运算符的结合性和优先级的实现方式。当表达式展开时，它变成27/3*3*3而不是27/(3*3*3)现在，除法和乘法在C中具有相同的优先级，但结合性都是从左到右的。所以它可以表示为：(27/3)*3*3，反过来等于(9*3)*3+=+81，如果你还记得BODMAS(括号关闭除法加法减法)的旧算术规则，这是优先顺序，然后我们先做除法，再做乘法。因此，对于27/3*3*3，我们得到的答案是81。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|749423|entityMap^0|U|L|3J|I|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

its the way in which the associativity and precedence of operators is implemented.
when the expression is expanded it becomes 
27/3*3*3 and not 27/(3*3*3)
now, division and multiplication both have the same precedence in C but the associativity is left to right for both.
so it can be shown as :
(27/3)*3*3 which in turn equals (9*3)*3 = 81
also, if u remember the old arithmetic rule of BODMAS(Bracket Off Division Multiplication Addition Subtraction), this is the order of precedence, then we do division first and then multiplication. 
so again we get answer as 81 for 27/3*3*3.

blocks|key|750048|text|对此的答案是:81解释:在步骤k=27/+preprocessor.then+(3)中，立方体(3)被3*3*3替换为3*3*3。上面的语句变成as+k=+27/3+*3*3+*3在27/3表达式中由c编译器求值(运算符优先)结果是(27/3)+:9语句k=27/3*3*3变成k=9*3*3；以上语句的结果是81：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|750049|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|$]]

Hi answer for this is:81
Explanation:
In step k=27/cube(3)
cube(3) is replaced by 3*3*3 by preprocessor.then above statement becomes as k=27/3*3*3
in that 27/3 expression is evaluated by c compiler(operator precedence)
the result is(27/3) :9
the statement k=27/3*3*3 becomes as k=9*3*3;
the result for above statement is 81:

This is a normal C routine program which i found out in some question bank. It is shown below:

<pre><code>#define CUBE(p) p*p*p

main()
{
 int k;
 k = 27 / CUBE(3);
 printf("%d", k);
}
</code></pre>

As per my understanding and knowledge the value of K should be 1 as CUBE(3) would be replaced by 3*3*3 during preprocessing and after the subsequent compilation it would be giving the value of 1, but instead it has shown the value of 81 which has made me curious to know how it happened.

Can anyone please justify the answer of 81 to this question above.

Using macro results in incorrect output when used as part of a larger math expression - why does this happen?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

这是一个普通的C程序，我在一些题库中发现的。如下图所示：#define CUBE(p) p*p*pmain(){    int k;    k = 27 / CUBE(3);    printf("%d", k);}根据我的理解和知识，K的值应该是1，因为在预处理过程中，CUBE(3)会被3*3*3替换，在随后的编译之后，它会给出1的值，但它显示的值是81，这让我很好奇它是如何发生的。对于上面这个

问使用宏作为更大的数学表达式的一部分时，会导致不正确的输出-为什么会发生这种情况？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用宏作为更大的数学表达式的一部分时，会导致不正确的输出-为什么会发生这种情况？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用宏作为更大的数学表达式的一部分时，会导致不正确的输出-为什么会发生这种情况？
EN