После прочтения 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. Где это определено в стандарте и откуда оно взялось?
-->
не является оператором. На самом деле это два отдельных оператора, --
и >
.
Условный код уменьшает значение x
, возвращая исходное (не уменьшенное) значение x
, а затем сравнивает исходное значение с 0
с помощью оператора >
.
Чтобы лучше понять, выражение может быть написано следующим образом:
while( (x--) > 0 )
Или для чего-то совершенно другого... х скользит к 0
while (x --\
\
\
\
> 0)
printf("%d ", x);
Не так математично, но... каждая картина рисует тысячу слов...
Это очень сложный оператор, поэтому даже ISO/IEC JTC1 (Joint Technical Committee 1) разместил свое описание в двух разных частях С++ Стандартный.
Шутя в сторону, это два разных оператора: --
и >
, описанные соответственно в разделе 5.2.6/2 и в разделе 5.9 стандарта С++ 03.
Это эквивалентно
while (x-- > 0)
x--
(после декремента) эквивалентно x = x-1
поэтому код преобразуется в:
while(x > 0) {
x = x-1;
// logic
}
0 >-- x
В этом случае x
уменьшается до логики. В постфиксе логика выполняется перед уменьшением, и, таким образом, оба образца эквивалентны. Не стесняйтесь записывать их в Console
и тестировать их.
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
;)
printf()
, потому что OP использует его), который должен компилироваться везде, поэтому это должна быть ваша ошибка. coliru.stacked-crooked.com/a/f5fdc710da0398c9
Это
#include <stdio.h>
int main(void){
int x = 10;
while( x-- > 0 ){ // x goes to 0
printf("%d ", x);
}
return 0;
}
Просто пространство делает вещи забавными, --
уменьшается и >
сравнивается.
Использование -->
имеет историческую значимость. Decrementing был (и по-прежнему в некоторых случаях), быстрее, чем приращение архитектуры 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;
}
Одна книга, которую я прочитал (я не помню, правильно, какую книгу) заявил: Компиляторы пытаются разобрать выражения на самый большой токен, используя правило 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
Надеюсь, это поможет понять сложное выражение ^^
a-----b
и подумает (a--)-- - b
, что не компилируется, потому что a--
не возвращает lvalue.
x
и --
это два отдельных токена.
Это точно так же, как
while (x--)
{
printf("%d ", x);
}
для неотрицательных чисел
for(--x++;--x;++x--)
?
unsigned
В любом случае у нас теперь есть оператор "идет". "-->"
легко запомнить как направление, а "while x обращается в нуль" означает "прямолинейно".
Кроме того, он немного эффективнее, чем "for (x = 10; x > 0; x --)"
на некоторых платформах.
for (size_t x=10; x-->0; )
тело цикла выполняется с 9,8, .., 0, тогда как другая версия имеет 10,9, .., 1. В противном случае выйти из цикла с нуля с помощью переменной без знака довольно сложно.
Этот код сначала сравнивает 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 переходит в 0".
while( x-- > 0 ) actually means while( x > 0)
- я не уверен, что вы пытались сказать там, но то, как вы это сформулировали, подразумевает --
имеет никакого значения, что, очевидно, очень неправильно ,
Между --
и >
пробел отсутствует. x
пост декрементируется, т.е. уменьшается после проверки условия x>0 ?
.
#define foo()
против #define foo ()
.
--
- оператор декремент, а >
- оператор больше.
Два оператора применяются как один, например -->
.
Это комбинация двух операторов. Первый --
предназначен для уменьшения значения, а >
- для проверки того, больше ли значение, чем правый операнд.
#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
пост-декрементируется и проверяется это условие. Это не -->
, it (x--) > 0
Примечание: значение x
изменяется после проверки условия, поскольку оно пост-декрементируется. Некоторые аналогичные случаи также могут иметь место, например:
--> x-->0
++> x++>0
-->= x-->=0
++>= x++>=0
while (0 <-- x)
также работать, тогда?
C и C++ подчиняются правилу "максимум munch". Точно так же, как --- 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--
является только сокращением для выше, а >
является просто нормальным более x--
operator
. Нет большой тайны!
Там слишком много людей, делающих простые вещи сложными в настоящее время;)
В обычном способе мы определяем условие в скобках цикла "()
" и условие завершения внутри фигурных скобок "{}
", но это --
и >
- это способ, которым каждый определяет все сразу.
Например, например:
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
}
}
в обоих направлениях, мы делаем то же самое и достигаем тех же целей.
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
.
Если вы должны были написать функцию, чтобы сделать обратный, синтаксис гораздо более очевидный, не говоря уже о том, что я не думаю, что видел его раньше:
#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
-->
- это в основном то же самое, что:
for(x=10; x<1; ++x)
cout<<x
вы находите все числа между x и заданным числом.
На самом деле → не один оператор. Это комбинация двух отдельных операторов - и >
Давайте рассмотрим пример. В то время как (х → 0) Это одно конфиденциальное выражение с одним подтверждением. Здесь первый x является декрементом с его значением, а затем сравнивается с 0.
++
или--
раньше ...