njtynhj

After reading Hidden Features and Dark Corners of C++/STL on comp.lang.c++.moderated, I was completely surprised that the following snippet compiled and worked in both Visual Studio 2008 and G++ 4.4.

Here's the code:

I'd assume this is C, since it works in GCC as well. Where is this defined in the standard, and where has it come from?

--> is not an operator. It is in fact two separate operators, -- and >.

The conditional's code decrements x, while returning x's original (not decremented) value, and then compares the original value with 0 using the > operator.

To better understand, the statement could be written as follows:

Or for something completely different... x slides to 0

Not so mathematical, but... every picture paints a thousand words. ...

That's a very complicated operator, so even ISO/IEC JTC1 (Joint Technical Committee 1) placed its description in two different parts of the C++ Standard.

Joking aside, they are two different operators: -- and > described respectively in §5.2.6/2 and §5.9 of the C++03 Standard.

It's equivalent to

x can go to zero even faster in the opposite direction:

8 6 4 2

You can control speed with an arrow!

90 80 70 60 50 40 30 20 10

;)

It's

Just the space make the things look funny, -- decrements and > compares.

The usage of --> has historical relevance. Decrementing was (and still is in some cases), faster than incrementing on the x86 architecture. Using --> suggests that x is going to 0, and appeals to those with mathematical backgrounds.

is how that's parsed.

Utterly geek, but I will be using this:

One book I read (I don't remember correctly which book) stated: Compilers try to parse expressions to the biggest token by using the left right rule.

In this case, the expression:

Parses to biggest tokens:

The same rule applies to this expression:

After parse:

I hope this helps to understand the complicated expression ^^

This is exactly the same as

for non-negative numbers

Anyway, we have a "goes to" operator now. "-->" is easy to be remembered as a direction, and "while x goes to zero" is meaning-straight.

Furthermore, it is a little more efficient than "for (x = 10; x > 0; x --)" on some platforms.

This code first compares x and 0 and then decrements x. (Also said in the first answer: You're post-decrementing x and then comparing x and 0 with the > operator.) See the output of this code:

We now first compare and then decrement by seeing 0 in the output.

If we want to first decrement and then compare, use this code:

That output is:

My compiler will print out 9876543210 when I run this code.

As expected. The while( x-- > 0 ) actually means while( x > 0). The x-- post decrements x.

is a different way of writing the same thing.

It is nice that the original looks like "while x goes to 0" though.

There is a space missing between -- and >. x is post decremented, that is, decremented after checking the condition x>0 ?.

-- is the decrement operator and > is the greater-than operator.

The two operators are applied as a single one like -->.

It's a combination of two operators. First -- is for decrementing the value, and > is for checking whether the value is greater than the right-hand operand.

The output will be:

Actually, x is post-decrementing and with that condition is being checked. It's not -->, it's (x--) > 0

Note: value of x is changed after the condition is checked, because it post-decrementing. Some similar cases can also occur, for example:

C and C++ obey the "maximum munch" rule. The same way a---b is translated to (a--) - b, in your case x-->0 translates to (x--)>0.

What the rule says essentially is that going left to right, expressions are formed by taking the maximum of characters which will form an valid expression.

Why all the complication?

The simple answer to the original question is just:

Does the same thing. Not saying you should do it like this, but it does the same thing and would have answered the question in one post.

The x-- is just shorthand for the above, and > is just a normal greater-than operator. No big mystery!

There's too much people making simple things complicated nowadays ;)

Conventional way we define condition in while loop parenthesis"()" and terminating condition inside the braces"{}", but this -- & > is a way one defines all at once.
For e.g:

It says, decrement a and run the loop till the time a is greater than 0

Other way it should have been like:

both ways, we do the same thing and achieve the same goals.

Thank you for your interest in this question.
Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).


Would you like to answer one of these unanswered questions instead?