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




тернарный оператор c++ (17)

Это

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

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

       printf("%d ", x);
     }

     return 0;
}

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

Прочитав Hidden Features и Dark Corners из 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);
    }
}

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


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

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


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

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

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


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()
{
    int x = 10;
    while (x > 0) 
    {
        printf("%d ", x);
        x = x-1;
    }
}

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

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

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


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

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

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

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

while((x--) > 0)

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

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


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

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

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

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


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

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

Приятно, что оригинал выглядит как «while x is to 0».


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

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

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


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


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

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


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


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

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

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

while( x-- > 0 )

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







standards-compliance