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

После прочтения скрытых объектов и темные углы C ++ / 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);
    }
}

Вывод:

9 8 7 6 5 4 3 2 1 0

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

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

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

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

while( (x--) > 0 )

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

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

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

Это очень сложный оператор, поэтому даже ISO / IEC JTC1 (Объединенный технический комитет 1) поместил свое описание в две разные части стандарта C ++.

Шутки в сторону, они представляют собой два разных оператора: --и >описаны , соответственно , в §5.2.6 / 2 и §5.9 на C ++ 03 стандарта.

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

while (x-- > 0)

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

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

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

;)

Это

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

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

       printf("%d ", x);
     }

     return 0;
}

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

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

while( x-- > 0 )

Вот как это проанализировано.

Совершенно отвратительный, но я буду использовать это:

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

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

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

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

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

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

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

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

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

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

Этот код сначала сравнивает 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

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

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

Приятно, что оригинал выглядит как «пока х уходит в 0».

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

--является оператором декремента и >является оператором больше, чем .

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

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

#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            

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

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

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

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

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

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

Простой ответ на оригинальный вопрос просто:

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

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

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

Сейчас слишком много людей делают простые вещи сложными;)

Традиционным образом мы определяем условие в whileскобках цикла ()и условие завершения внутри фигурных скобок {}, но -->определяем оба сразу.

Например:

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

Это уменьшает aи запускает цикл, пока aбольше, чем 0.

Условно это будет выглядеть так:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

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

(x --> 0) средства (x-- > 0)

1. ты можешь использовать (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. Вы можете использовать (-- x > 0) Это значит(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. ты можешь использовать

(--\
    \
     x > 0)

output -: 9 8 7 6 5 4 3 2 1

4. ты можешь использовать

(\
  \
   x --> 0)

output -: 9 8 7 6 5 4 3 2 1 0

5. ты можешь использовать

(\
  \
   x --> 0
          \
           \
            )

output -: 9 8 7 6 5 4 3 2 1 0

6. Вы также можете использовать

(
 x 
  --> 
      0
       )

output -: 9 8 7 6 5 4 3 2 1 0

Кроме того, вы можете попробовать много методов, чтобы успешно выполнить эту команду