On a related note, what about the following:
static int foo;
static int bar(void)
{
return foo++;
}
int main(void)
{
return foo++ - bar();
}
I would have to say that this is unspecified behavior, not undefined.
There are these possibilities.
Scenario 1:
The processing of the foo++ in main takes place like this. First foo
has to be accessed, and then the new value stored. So the call to bar can occur
in three abstract places: 1) before foo is accessed, 2) after it is accessed but
before the new value is stored, or 3) after the new value is stored.
Case 1 is similar to this:
int temp = bar();
return foo++ - temp; /* foo becomes 2, 1 returned */
Case 2 is similar to this:
int temp0 = foo, temp1 = bar(); /* 0, 0 */
return foo = temp0 + 1, temp0; /* foo becomes 1, 0 returned */
Case 3:
int temp = foo++; /* 0, foo becomes 1 */
return temp - bar(); /* foo becomes 2, -1 returned */
Notice the symmetry between case 1 and 3. 2 is the most complex; we need
to expose its semantics using two temporary values. This is because the call to
bar() is interposed into the evaluation of foo++.
Scenario 2:
foo++ works by accessing the value, adding 1 to it, storing the new value,
accessing the value again and then subtracting 1 to produce the resulting
value. If foo is not volatile, this is allowed because the accesses are not
visible behavior. Now bar() can be called first, after the value is accessed,
after it is stored, then after it is accessed again. Here you have four cases
that can be worked out similarly to Scenario 1.
