Query:
Here’s the code:
#include <stdio.h>
int main()
{
int x = 10;
while (x --> 0) // x goes to 0
{
printf("%d ", x);
}
}
Output:
9 8 7 6 5 4 3 2 1 0
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?
What is the “–>” operator in C/C++? Answer #1:
-->
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:
while( (x--) > 0 )
Answer #2:
Or for something completely different… x
slides to 0
.
while (x --\
\
\
\
> 0)
printf("%d ", x);
Not so mathematical, but… every picture paints a thousand words.
Answer #3:
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.
Answer #4:
x
can go to zero even faster in the opposite direction:
int x = 10;
while( 0 <---- x )
{
printf("%d ", x);
}
8 6 4 2
You can control speed with an arrow!
int x = 100;
while( 0 <-------------------- x )
{
printf("%d ", x);
}
90 80 70 60 50 40 30 20 10
Answer #5:
It’s equivalent to
while (x-- > 0)
x--
(post decrement) is equivalent to x = x-1
so, the code transforms to:
while(x > 0) {
x = x-1;
// logic
}
x--; // The post decrement done when x <= 0
Answer #6:
It’s
#include <stdio.h>
int main(void) {
int x = 10;
while (x-- > 0) { // x goes to 0
printf("%d ", x);
}
return 0;
}
Just the space makes the things look funny, --
decrements and >
compares.
Answer #7:
Utterly geek, but I will be using this:
#define as ;while
int main(int argc, char* argv[])
{
int n = atoi(argv[1]);
do printf("n is %d\n", n) as ( n --> 0);
return 0;
}
Answer #8:
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.
Answer #9:
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:
x-->0
Parses to biggest tokens:
token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0
The same rule applies to this expression:
a-----b
After parse:
token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b
I hope this helps to understand the complicated expression ^^.
Answer #10:
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:
9 8 7 6 5 4 3 2 1 0
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:
#include <stdio.h>
int main(void)
{
int x = 10;
while( --x> 0 ) // x goes to 0
{
printf("%d ", x);
}
return 0;
}
That output is:
9 8 7 6 5 4 3 2 1
Answer #11:
My compiler will print out 9876543210 when I run this code.
#include <iostream>
int main()
{
int x = 10;
while( x --> 0 ) // x goes to 0
{
std::cout << x;
}
}
As expected. The while( x-- > 0 )
actually means while( x > 0)
. The x--
post decrements x
.
while( x > 0 )
{
x--;
std::cout << x;
}
is a different way of writing the same thing.
It is nice that the original looks like “while x goes to 0” though.
Hope you learned something from this post.
Follow Programming Articles for more!