C return a++ - is it safe?

[James Harris]

If in C one codes a function which includes

return a++;

does 'a' get incremented? Would the behaviour be safe to rely upon? I
guess this might apply if 'a' were static or such as

return ptr->element++;

I didn't find this in the comp.lang.c faq (at least the first one that
came up from Google; there seemed to be many) but didn't find it. No
doubt someone will tell me where I should have looked.

(For the time being I'm coding: a++; return a - 1; )
--
James

[Richard Bos]

Tor Rustad <to********@hot mail.comwrote:

Chris Hills wrote:

In article <bJ************ *********@telen or.com>, Tor Rustad

Kenneth Brody wrote:

First, I didn't agree with Chris Hills, because

1. I didn't find such a C compiler bug likely

"Likely" is not good enough. You have to be certain.

"Testing can show the presence of errors, but not their absence."
-E. W. Dijkstra

"Beware of bugs in the above code; I have only proved it correct, not
tried it." - Donald E. Knuth

Still, there is a non-zero probability, that the same compiler fault can
hit all of them, e.g. via some common mode of failure.

Highly likely, in fact, if they're all working from the same specs.

Richard

[Ben Bacarisse]

oz****@bigpond. com (ozbear) writes:

On Sat, 03 Nov 2007 03:34:58 +0000, Ben Bacarisse
<be********@bsb .me.ukwrote:

>>James Harris <ja************ @googlemail.com writes:

>>On 30 Oct, 20:10, Keith Thompson <[e-mail] rote:
...
Consider how the return statement is defined: the expression is
evaluated, and the result is returned. Updating ``a'' is part of the
evaluation of the expression.

Is there some particular reason you're concerned that a compiler might
handle something this simple incorrectly?

In any context other than a return statement
mov eax, a
{use eax}
inc eax

Not quite "any". In a function call, f(a++) the side-effects must
have happened by the time function is entered. Of course, if the "use
it" is "push it" and the function call follows the inc (and another
mov) we are OK, but the same could also be done for the return (the
"use it" being put into register used for return values).

<snip>

I am not quite sure I understand what you are saying. While a
sequence point does occur just before and after the function call, the
value of /a/ passed will be its pre-incremented value.

Yes. I was making a very small point. The discussion was about how
likely it is that 'return a++;' will be miss-compiled. James Harris
pointed out that "in any context other than return" the compiler can
load the value of a, generate the code that uses it, then emit an
increment instruction. I was just pointing out that 'f(a++);' is
similar -- the code that uses 'a' gets the prior value but the
increment must have happened before any of that code is executed.

--
Ben.