Question

In this question,I’m asking how the following snippets work, as it involves weird use of variable:

while (+(+i--)!=0)
{
    i-=i++;
}
console.log(i);

Answer 1

Interesting problem… you’ve tagged it Java, JavaScript and C — note that while these languages have the same syntax, this question involves very subtle semantics that may (I’m not sure) differ across languages.

Let’s break it down:

+(+i--)

The -- postfix decrement operator is most tightly bound. So this is equivalent to +(+(i--)). That is therefore equivalent to the value of +(+i) (that is, i), but it also decrements i after taking the value. It compares the value with 0 to see if the loop should continue. Thus, while (+(+i--)!=0) is equivalent to the following:

while (i-- != 0)

Note that it also performs i-- at the end of the loop.

Inside the loop, I believe you have some undefined behaviour, at least in C, because you are referencing i on the right, and also updating i on the left — I believe that C doesn’t define which order to do that in. So your results will probably vary from compiler to compiler. Java, at least, is consistent, so I’ll give the Java answer. i-=i++ is equivalent i = i - i++, which is equivalent to to reading all the values out of the expression, computing the result of the expression, applying the post-increment, and then assigning the result back. That is:

int t = i - i;    // Calculate the result of the expression "i - i++"
i++;              // Post-increment i
i = t;            // Store the result back

Clearly, this is the same as writing i = 0. So the body of the loop sets i to 0.

Thus, the loop executes just one time, setting i to 0. Then, it decrements i one more time on the next while loop, but fails the check because i (before decrementing) == 0.

Hence, the final answer is -1, no matter what the initial value for i is.

To put this all together and write an equivalent program:

while (i-- != 0)
{
    int t = i - i;
    i++;
    i = t;
}
console.log(i);

When I tried it in Java and JavaScript, that’s what I got. For GCC (C compiler), it gives -1 only when i starts out as 0. If i starts out as anything else, it goes into an infinite loop.

That’s because in GCC (not necessarily all C compilers), i-=i++ has a different meaning: it does the store back to i first, then does the post-increment. Therefore, it is equivalent to this:

int t = i - i;    // Calculate the result of the expression "i - i++"
i = t;            // Store the result back
i++;              // Post-increment i

That’s equivalent to writing i = 1. Therefore, on the first iteration, it sets i to 1, and then on the loop, it checks whether i == 0, and it isn’t, so it goes around again, always setting i to 1. This will never terminate, but for the special case where i starts out as 0; then it will always terminate the loop and decrement i (so you get -1).

Another C compiler may choose to act like Java instead. This shows that you should never write code which both assigns and postincrements the same variable: you never know what will happen!

Edit: I tried to be too clever using that for loop; that wasn’t equivalent. Turned back into a while loop.