当前位置 : 首页 » 互动问答 » 正文

What is the "-->" operator in C++?

分类 : 互动问答 | 发布时间 : 2009-10-29 14:57:45 | 评论 : 21 | 浏览 : 633235 | 喜欢 : 8057

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:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

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?

回答(21)

  • 1楼
  • Pay attention

    --> 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)
    
  • 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. ...

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

  • 4楼
  • It's equivalent to

    while (x-- > 0)
    
  • 5楼
  • 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

    ;)

  • 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 make the things look funny, -- decrements and > compares.

  • 7楼
  • 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.

  • 8楼
  • while( x-- > 0 )
    

    is how that's parsed.

  • 9楼
  • 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;
    }
    
  • 10楼
  • 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 ^^

  • 11楼
  • This is exactly the same as

    while (x--)
    {
       printf("%d ", x);
    }
    

    for non-negative numbers

  • 12楼
  • 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.

  • 13楼
  • 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
    
  • 14楼
  • 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.

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

  • 16楼
  • -- is the decrement operator and > is the greater-than operator.

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

  • 17楼
  • 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.

    #include<stdio.h>
    
    int main()
    {
        int x = 10;
    
        while (x-- > 0)
            printf("%d ",x);
    
        return 0;
    }
    

    The output will be:

    9 8 7 6 5 4 3 2 1 0            
    
  • 18楼
  • 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:

    -->    x-->0
    ++>    x++>0
    -->=   x-->=0
    ++>=   x++>=0
    
  • 19楼
  • 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.

  • 20楼
  • Why all the complication?

    The simple answer to the original question is just :

    #include <stdio.h>
    int main()
    {
        int x = 10;
        while (x > 0) 
        {
            printf("%d ", x);
            x = x-1;
        }
    }
    

    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 ;)

  • 21楼
  • 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:

    int abc(){
        int a = 5
        while((a--) > 0){ // Decrement and comparison both at once
            // Code
        }
    }
    

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

    Other way it should have been like:

    int abc(){
        int a = 5
        while(a > 0){
            // Code
            a = a -1 // Decrement inside loop
        }
    }
    

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

相关阅读:

How to convert string to char array in C++?

Which equals operator (== vs ===) should be used in JavaScript comparisons?

Does Python have a ternary conditional operator?

Why is it faster to process a sorted array than an unsorted array?

What does the C++ standard state the size of int, long type to be?

Best C++ IDE or Editor for Windows

Convert char to int in C and C++

usr/bin/ld: cannot find -l<nameOfTheLibrary>

Calling C++ class methods via a function pointer

What is the best way to use a HashMap in C++?