Что такое оператор «->» в С++?

После прочтения Hidden Features и Dark Corners of С++/STL на comp.lang.c++.moderated, я был полностью удивлен, что следующий фрагмент, скомпилированный и работающий в как Visual Studio 2008, так и g++ 4.4.

Здесь код:

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

Я бы предположил, что это C, так как он работает и в GCC. Где это определено в стандарте и откуда оно взялось?

Вам также может понравиться

About the Author: qw

25 комментариев

  1. Обращать внимание

    --> не является оператором. Это фактически два отдельных оператора, -- и >.

    Условный код уменьшает x, возвращая x исходное (не уменьшенное) значение, а затем сравнивает исходное значение с 0 с помощью оператора >.

    Чтобы лучше понять, выражение можно было бы написать следующим образом:

    while((x--) > 0)
    

  2. Или для чего-то совершенно другого… x слайдов до 0

    while (x --
                
                 
                  
                   > 0)
         printf("%d ", x);
    

    Не так математично, но… каждая картина рисует тысячу слов….

  3. Это очень сложный оператор, поэтому даже ISO/IEC JTC1 (Joint Technical Committee 1) разместил свое описание в двух разных частях С++ Стандартный.

    Шутя в сторону, это два разных оператора: -- и >, описанные соответственно в разделе 5.2.6/2 и в разделе 5.9 стандарта С++ 03.

  4. x может идти до нуля еще быстрее в обратном направлении:

    int x = 10;
    
    while( 0 <---- x )
    {
       printf("%d ", x);
    }
    

    8 6 4 2

    Вы можете управлять скоростью со стрелкой!

    int x = 100;
    
    while( 0 <-------------------- x )
    {
       printf("%d ", x);
    }
    

    90 80 70 60 50 40 30 20 10

    😉

  5. Это

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

    Просто пространство делает вещи забавными, -- уменьшается и > сравнивается.

  6. Использование --> имеет историческую значимость. Decrementing был (и по-прежнему в некоторых случаях), быстрее, чем приращение архитектуры x86. Используя -->, предположим, что x подходит к 0 и обращается к тем, у кого есть математический фон.

  7. Полностью выродка, но я буду использовать это:

    #define as ;while
    
    int main(int argc, char* argv[])
    {
        int n = atoi(argv[1]);
        do printf("n is %dn", n) as ( n --> 0);
        return 0;
    }
    

  8. Одна книга, которую я прочитал (я не помню, правильно, какую книгу) заявил: Компиляторы пытаются разобрать выражения на самый большой токен, используя правило left right.

    В этом случае выражение:

    x-->0
    

    Парсы для самых больших токенов:

    token 1: x
    token 2: --
    token 3: >
    token 4: 0
    conclude: x-- > 0
    

    То же правило применяется к этому выражению:

    a-----b
    

    После синтаксического анализа:

    token 1: a
    token 2: --
    token 3: --
    token 4: -
    token 5: b
    conclude: (a--)-- - b
    

    Надеюсь, это поможет понять сложное выражение ^^

  9. В любом случае у нас теперь есть оператор "идет". "-->" легко запомнить как направление, а "while x обращается в нуль" означает "прямолинейно".

    Кроме того, он немного эффективнее, чем "for (x = 10; x > 0; x --)" на некоторых платформах.

  10. Этот код сначала сравнивает x и 0, а затем уменьшает x. (Также сказано в первом ответе: вы пост-декрементируете x, а затем сравниваете x и 0 с оператором >.) См. Вывод этого кода:

    9 8 7 6 5 4 3 2 1 0
    

    Теперь мы сначала сравниваем, а затем уменьшаем, видя 0 на выходе.

    Если мы хотим сначала уменьшить, а затем сравнить, используйте этот код:

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

    Этот вывод:

    9 8 7 6 5 4 3 2 1
    

  11. Мой компилятор распечатает 9876543210 при запуске этого кода.

    #include <iostream>
    int main()
    {
        int x = 10;
    
        while( x --> 0 ) // x goes to 0
        {
            std::cout << x;
        }
    }
    

    Как и ожидалось. Значение while( x-- > 0 ) означает while( x > 0). x-- пост декременты x.

    while( x > 0 ) 
    {
        x--;
        std::cout << x;
    }
    

    — это другой способ написать одно и то же.

    Приятно, что оригинал выглядит как "while x переходит в 0".

  12. Между -- и > пробел отсутствует. x пост декрементируется, т.е. уменьшается после проверки условия x>0 ?.

  13. -- — оператор декремент, а > — оператор больше.

    Два оператора применяются как один, например -->.

  14. Это комбинация двух операторов. Первый -- предназначен для уменьшения значения, а > — для проверки того, больше ли значение, чем правый операнд.

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

    Выход будет:

    9 8 7 6 5 4 3 2 1 0            
    

  15. Фактически, x пост-декрементируется и проверяется это условие. Это не -->, it (x--) > 0

    Примечание: значение x изменяется после проверки условия, поскольку оно пост-декрементируется. Некоторые аналогичные случаи также могут иметь место, например:

    -->    x-->0
    ++>    x++>0
    -->=   x-->=0
    ++>=   x++>=0
    

  16. C и C++ подчиняются правилу "максимум munch". Точно так же, как — b переводится на (a--) - b, в вашем случае x-->0 переводится на (x--)>0.

    То, что правило гласит по существу, состоит в том, что движение слева направо, выражения формируются путем принятия максимума символов, которые будут формировать правильное выражение.

  17. Почему все осложнения?

    Простой ответ на исходный вопрос:

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

    Делает то же самое. Не говоря, что вы должны делать это так, но он делает то же самое и ответил бы на один вопрос.

    x-- является только сокращением для выше, а > является просто нормальным более x-- operator. Нет большой тайны!

    Там слишком много людей, делающих простые вещи сложными в настоящее время;)

  18. В обычном способе мы определяем условие в скобках цикла "()" и условие завершения внутри фигурных скобок "{}", но это -- и > — это способ, которым каждый определяет все сразу.
    Например, например:

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

    Он говорит, уменьшает a и запускает цикл до тех пор, пока время a больше, чем 0

    Другим способом это должно было быть:

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

    в обоих направлениях, мы делаем то же самое и достигаем тех же целей.

  19. C/C++ игнорирует пробелы с условием. По сути, код

    while (x --> 0)
    

    это то же самое, что и

    while (x-- > 0)
    

    или

    while(x > 0){
       x = x - 1
    ...
    

    Используя пост-декремент в условии. Пусть говорят x = 10. Оператор условия будет равен 10>0 и printf("%d ", x); оператор в цикле даст 9 в первом прогоне. Для второго запуска условие будет 9>0 а печать будет равна 8 и так далее до условия 0>0.

  20. Если вы должны были написать функцию, чтобы сделать обратный, синтаксис гораздо более очевидный, не говоря уже о том, что я не думаю, что видел его раньше:

        #include <stdio.h>
        int main()
        {
            int x {10}; while (x ++< 20) // x increments to 20
            {
                printf("%d ", x);
            }
        }
    

    Результат:

    11 12 13 14 15 16 17 18 19 20

  21. На самом деле → не один оператор.
    Это комбинация двух отдельных операторов — и >

    Давайте рассмотрим пример.
    В то время как (х → 0)
    Это одно конфиденциальное выражение с одним подтверждением. Здесь первый x является декрементом с его значением, а затем сравнивается с 0.

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *