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

После прочтения 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. Где это определено в стандарте и откуда оно взялось?

8281
29 окт. '09 в 9:57
источник поделиться
25 ответов

--> не является оператором. На самом деле это два отдельных оператора, -- и >.

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

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

while( (x--) > 0 )
7970
29 окт. '09 в 10:00
источник

Связанные вопросы


Похожие вопросы

Или для чего-то совершенно другого... х скользит к 0

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

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

2735
18 янв. '12 в 14:18
источник

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

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

2297
29 окт. '09 в 11:38
источник

Это эквивалентно

while (x-- > 0)

x-- (после декремента) эквивалентно x = x-1 поэтому код преобразуется в:

while(x > 0) {
    x = x-1;
    // logic
}
1214
29 окт. '09 в 10:00
источник

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

;)

1031
28 дек. '14 в 3:32
источник

Это

#include <stdio.h>
int main(void){
     int x = 10;

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

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

524
29 окт. '09 в 10:00
источник

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

394
18 нояб. '09 в 15:47
источник
while( x-- > 0 )

как это анализируется.

343
29 окт. '09 в 10:00
источник

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

#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;
}
329
18 мая '10 в 23:33
источник

Одна книга, которую я прочитал (я не помню, правильно, какую книгу) заявил: Компиляторы пытаются разобрать выражения на самый большой токен, используя правило 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

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

302
09 апр. '10 в 3:04
источник

Это точно так же, как

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

для неотрицательных чисел

252
31 дек. '10 в 16:48
источник

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

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

230
29 окт. '09 в 17:45
источник

Этот код сначала сравнивает 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
212
18 нояб. '09 в 15:52
источник

Мой компилятор распечатает 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".

167
17 янв. '10 в 3:46
источник

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

138
28 дек. '10 в 19:32
источник

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

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

129
06 апр. '10 в 13:45
источник

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

#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            
123
02 апр. '13 в 14:22
источник

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

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

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0
117
18 авг. '12 в 10:34
источник

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

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

113
10 февр. '14 в 20:29
источник

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

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

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

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

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

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

26
27 окт. '16 в 18:09
источник

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

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) {
        a = a -1 // Decrement inside loop
        // Code
    }
}

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

23
28 мая '17 в 23:10
источник

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.

0
06 сент. '18 в 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

-1
13 июля '18 в 18:34
источник

--> - это в основном то же самое, что:

 for(x=10; x<1; ++x)
    cout<<x

вы находите все числа между x и заданным числом.

-1
14 апр. '18 в 21:59
источник

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

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

-4
06 дек. '17 в 16:45
источник

Посмотрите другие вопросы по меткам или Задайте вопрос