blocks|key|1516535|text|就像使用括号时经常出现的情况一样，我认为这只是为了可读性(例如，Ruby支持方法调用时不使用括号将参数括起来，但最近的书籍和文章提出了不同的建议)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1516536|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 often the case when using parenthesis, I think that's just for readability (e.g., Ruby supports method calls w/o parenthesis enclosing the arguments but recent books and articles advise otherwise).

blocks|key|1731637|text|这真的没有什么原因...这只是一个古老的惯例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1731638|为了节省空间，程序员通常会在返回行而不是它自己的行中执行最后的数学运算，并且确保存在的括号主要是为了更容易地看到它是一个返回的语句，如下所示：|1731639|return+(x%2Bi*2);|code-block|syntax|javascript|1731640|而不是|1731641|int+y+=+x%2Bi*2;
return+y;|1731642|插入语成了一种习惯，而且它坚持了下来。|1731643|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|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

There really isn't a reason...it's just old convention.

To save space, programmers would often do the final math in the return line instead of on it's own line and the parens ensure are mostly there to make it easier to see that it is a single statement that is returned, like this:

<pre><code>return (x+i*2);
</code></pre>

instead of

<pre><code>int y = x+i*2;
return y;
</code></pre>

The parenthesis became a habit and it stuck.

blocks|key|1516669|text|我个人的风格是，如果有一个复杂的表达式，就使用括号；例如，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1516670|return+(a+%2B+b);|code-block|syntax|javascript|1516671|但如果表达式是一个简单的术语，则不使用它们|1516672|return+a;|1516673|我说不出我为什么那样做；只是我很久以前学到的东西。|1516674|顺便说一句，我认为让它看起来像一个函数调用，就像这样：|1516675|return(a);++//+ugh|1516676|是令人难以置信的丑陋和错误的。|1516677|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

My personal style is to use parentheses if there is a complex expression; e.g.,

<pre><code>return (a + b);
</code></pre>

but to not use them if the expression is a simple term

<pre><code>return a;
</code></pre>

I can't say why I do it that way; just something I picked up long ago.

By the way, I think that making it look like a function call, like this:

<pre><code>return(a); // ugh
</code></pre>

is incredibly ugly and just wrong.

blocks|key|1516704|text|一个实际但不太可能的动机是，如果您将值放在括号中，您可以将return定义为宏，然后插入一些日志记录代码来查看所有的返回。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1516705|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|$]]

A practical, but unlikely, motive is if you put parenthesis around the value, you can define return as a macro, and then insert some logging code to watch all your returns.

blocks|key|1516756|text|在返回-1时，比如在示例中，我认为带括号的-1更易读，因为减号更明显：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1516757|return+1|code-block|syntax|javascript|1516758|或|1516759|return+-1|1516760|1516761|return+(-1)|1516762|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

When returning -1 as in your excample, I think it's more readable with the parenthesis because the minus is more visible:

<pre><code>return 1
</code></pre>

or

<pre><code>return -1
</code></pre>

or

<pre><code>return (-1)
</code></pre>

blocks|key|1731879|text|在return语句中使用括号表明对C/C%2B%2B语法的掌握不足。事情就是这么简单。但这并不像把所有东西都放在大括号里那么糟糕：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1731880|int+foo(int+x)+{
++if+(x)+{
++++return+(-1);
++}
++else+{
++++return+(0);
++}
}|code-block|syntax|javascript|1731881|所以很多程序员都这样做。如果你们中的一个人读到了这篇文章，也许你会愿意解释一下。|1731882|entityMap^0|H|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Using parentheses in a return statement shows a deficient grasp of <code>C/C++</code> syntax. It's as simple as that. But it's not as bad as putting everything in curly braces:

<pre><code>int foo(int x) {
 if (x) {
 return (-1);
 }
 else {
 return (0);
 }
}
</code></pre>

So many programmers do this. If one of you reads this, perhaps you might like to explain.

blocks|key|1516846|text|也许这是一种习惯--毕竟，给我们带来Unix和C语言的人来自Multics项目。Multics是用PL/I编写的，在PL/I中括号是强制性的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1516847|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|$]]

Perhaps it's custom--after all, the folks who brought us Unix and C came from the Multics project. Multics was written in PL/I, and in PL/I the parentheses are mandatory.

blocks|key|1731984|text|return语句中的圆括号向编译器表明，您希望将此值返回到堆栈上，而不是内存中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1731985|在过去，这是严格执行的(通常)，但今天大多数编译器只将其作为一种提示。|1731986|这是我经常做的事情，因为错误可能会破坏通过内存引用返回的任何内容，但通常不会影响堆栈上返回的变量。|1731987|对临时变量使用堆栈还可以减少内存使用量，并且通常会使函数调用/返回更快，因为这就是为临时数据/变量而设计的堆栈。|1731988|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The Parenthesis in a return statement indicate to the compiler that you intend for this value to be returned on the stack instead of in memory.

In the old days this was rigorously enforced(typically), but today most compilers only take it as a hint.

This is something I do frequently, since an error could corrupt anything being returned via a memory reference, but typically wont effect a variable being returned on the stack.

Using the stack for transient variables also cuts down on memory usage and typically makes the function call/return quicker because that's what the stack is designed for, transient data/variables.

Quite often in ANSI C code I can see parenthesis sorrounding a single return value. 

Like this:-

<pre><code>int foo(int x) {
 if (x)
 return (-1);
 else
 return (0);
}
</code></pre>

Why use () around the return value in those cases? Any ideas? I can see no reason for that.

Parenthesis surrounding return values in C

在ANSI代码中，我经常可以看到圆括号对单个返回值进行排序。就像这样：int foo(int x) {  if (x)    return (-1);  else    return (0);}在这些情况下，为什么要在返回值周围使用()呢？有什么想法吗？我看不出有什么理由这样做。

问用括号将C语言中的返回值括起来
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用括号将C语言中的返回值括起来EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用括号将C语言中的返回值括起来
EN