# What is the “–>” operator in C/C++? [Answered]

### 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 )``

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.

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.

`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`

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``````

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.

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;
}``````

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.

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 ^^.

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``

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.