On 31/05/2026 10:49, David Brown wrote:As I said, they "do not affect the generated code unless they affect the semantics of the expression." Obviously that only applies to extra parentheses. If that's what you mean by "parsed differently", then we agree - clearly "(a + b) * c" gives different code from "a + (b * c)".On 31/05/2026 10:12, Richard Harnden wrote:They can do if they make a expression be parsed differently.On 31/05/2026 00:43, Keith Thompson wrote:>C's operator precedence rules are complicated and arguably flawed.>
They could have been defined differently. A simpler set of rules,
with fewer levels,*might* have been better. I don't have any
concrete suggestions -- nor do I have any strong preferences.
I accept C's rules as they are. I would accept them if they had
been defined differently.
Can't the compiler easily remove any parens that aren't necessary?
So - just write complex expressions in a way that a human can most easily understand, it makes your intention clear and probable doesn't increase the size of the executable.
>
>
Of course. Parentheses do not affect the generated code unless they affect the semantics of the expression. (Some people think parentheses affect the order of evaluation,
But you might consider "(a + b) + c" to be "parsed differently" than "a + (b + c)", because of how a particular compiler implements its parser. It's possible that this results in different code for a particular compiler, but there is no difference in the meaning for the C language.
I perhaps expressed it poorly when I said extra parentheses "do not" affect the generated code - extra parentheses do not change the meaning of the C code, and so compilers don't have to consider them in any way (and optimising compilers generally don't). But a compiler is, of course, free to be influenced by them and generate code that varies with extra parentheses, as long as the final results match those required by the standard.
Do you have an example where they make no difference but people might think they do?People might think they affect the order of evaluation, such as when you have function calls :
u = foo(x) + (foo(y) + foo(z));
Some people might think the use of parentheses means that "foo(y)" and "foo(z)" are called before "foo(x)", when the order of all these calls (and the additions) is unspecified. (Again, a given compiler might be influenced by the parentheses, but the language does not require it.)
Les messages affichés proviennent d'usenet.