Що таке оператор "->" в 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.2 / 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 ++ підкоряються правилу "максимальний стрибок". Таким же чином, як --- 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

також можна спробувати безліч методів для успішного виконання цієї команди