Что такое "-->" оператор в 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-- (пост декремент) эквивалентно 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;
    }
}

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

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

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

приятно, что оригинал выглядит как "в то время как 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;
    }
}

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

The 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
    }
}

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