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

или для чего-то совершенно другого... х упал до 0

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

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

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

шутки в сторону, это два разных оператора:-- и > описано соответственно в §5.2.6 / 2 и §5.9 стандарта C++03.

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

while (x-- > 0)

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

while(x > 0) {
    // logic
    x = x-1;
}

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

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

в любом случае, теперь у нас есть оператор" идет к". "-->" легко запоминается как направление, а "в то время как 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;
    }
}

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

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

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

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

между -- и >. x является post decremented, то есть decremented после проверки условия 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(){
    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
    }
}

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