Co to jest operator "-- > " w C / C++?

Albo za coś zupełnie innego... x slajdy do 0.

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

To bardzo skomplikowany operator, więc nawet ISO / IEC JTC1 (Joint Technical Committee 1) umieściło jego opis w dwóch różnych częściach standardu C++.

Są to dwa różne operatory: -- i > opisane odpowiednio w §5.2.6 / 2 i §5.9 standardu C++03.

Jest odpowiednikiem

while (x-- > 0)

x-- (post decrement) jest równoważne x = x-1, więc kod przekształca się na:

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

x może iść do zera jeszcze szybciej w przeciwnym kierunku:

int x = 10;

while( 0 <---- x )
{
   printf("%d ", x);
}

8 6 4 2

Możesz kontrolować prędkość za pomocą strzałki!

int x = 100;

while( 0 <-------------------- x )
{
   printf("%d ", x);
}

90 80 70 60 50 40 30 20 10

;)

To

#include <stdio.h>

int main(void) {
  int x = 10;
  while (x-- > 0) { // x goes to 0
    printf("%d ", x);
  }
  return 0;
}

Tylko przestrzeń sprawia, że rzeczy wyglądają śmiesznie, -- dekretuje i > porównuje.

Użycie --> ma znaczenie historyczne. Zmniejszanie było (i nadal jest w niektórych przypadkach) szybsze niż zwiększanie na architekturze x86. Użycie --> sugeruje, że {[2] } będzie 0 i odwołuje się do tych, którzy mają matematyczne pochodzenie.

Totalnie geek, ale będę używał tego:

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

while( x-- > 0 )

Jest jak to jest analizowane.

Jedna książka, którą przeczytałem (nie pamiętam dokładnie, która książka) stwierdziła: kompilatorzy próbują parsować wyrażenia do największego tokena używając reguły left right.

W tym przypadku wyrażenie:

x-->0

Parsuje do największych tokenów:

token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0

Ta sama zasada stosuje się do tego wyrażenia:

a-----b

Po analizie:

token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b

Mam nadzieję, że to pomoże zrozumieć skomplikowane wyrażenie ^^

To jest dokładnie to samo co

while (x--)
{
   printf("%d ", x);
}

Dla liczb nieujemnych

W każdym razie, mamy teraz operatora "idzie do". "-->" łatwo zapamiętać jako kierunek, a "while x goes to zero" oznacza-prosto.

Ponadto jest nieco bardziej wydajny niż "for (x = 10; x > 0; x --)" na niektórych platformach.

Ten kod najpierw porównuje x i 0, a następnie Dekrementuje x. (powiedział również w pierwszej odpowiedzi: po dekrementujesz x, a następnie porównujesz X i 0 z operatorem >.) Patrz wyjście tego kodu:

9 8 7 6 5 4 3 2 1 0

Najpierw porównujemy, a następnie zmniejszamy, widząc 0 na wyjściu.

Jeśli chcemy najpierw dekrementować, a następnie porównać, użyj tego kodu:

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

    while( --x> 0 ) // x goes to 0
    {
        printf("%d ", x);
    }
    return 0;
}

Wyjście To:

9 8 7 6 5 4 3 2 1

Mój kompilator wydrukuje 9876543210 kiedy uruchomię ten kod.

#include <iostream>
int main()
{
    int x = 10;

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

Zgodnie z oczekiwaniami. while( x-- > 0 ) w rzeczywistości oznacza while( x > 0). x-- post decrements x.

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

To inny sposób pisania tego samego.

Fajnie, że oryginał wygląda jak" while x goes to 0".

Pomiędzy -- a > brakuje spacji. x jest post decremented, czyli decremented po sprawdzeniu stanu x>0 ?.

-- jest operatoremdecrement i > jest operatoremwiększym od .

Oba operatory są stosowane jako jeden, jak -->.

Jest kombinacją dwóch operatorów. Pierwsza -- służy do zmniejszania wartości, a > do sprawdzania, czy wartość jest większa niż prawostronny operand.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

Wyjście będzie:

9 8 7 6 5 4 3 2 1 0            

Właściwie, {[1] } jest post-dekrementacja i z tym warunkiem jest sprawdzana. To nie -->, to (x--) > 0

Uwaga: wartość x jest zmieniana po sprawdzeniu warunku, ponieważ po jego zmniejszeniu. Niektóre podobne przypadki mogą również wystąpić, na przykład:

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

C i C++ przestrzegają zasady "maximum munch". W ten sam sposób a - - - b jest tłumaczone na (a--) - b, w Twoim przypadku x-->0 tłumaczy się na (x--)>0.

Zasada mówi zasadniczo, że przechodząc od lewej do prawej, wyrażenia są tworzone przez przyjęcie maksimum znaków, które będą tworzyć poprawne wyrażenie.

Skąd te komplikacje?

Prosta odpowiedź na pierwotne pytanie brzmi:

#include <stdio.h>

int main()
{
    int x = 10;
    while (x > 0)
    {
        printf("%d ", x);
        x = x-1;
    }
}

x-- jest tylko skrótem od powyższego, a > jest po prostu normalnym większym niż operator. Żadna tajemnica!

W dzisiejszych czasach jest zbyt wielu ludzi, którzy komplikują proste rzeczy;)

W konwencjonalny sposób definiujemy warunek w nawiasie pętli while "() "i warunek zakończenia wewnątrz nawiasu klamrowego" {}", ale to -- & > to sposób, w jaki definiuje się wszystkie naraz. Na przykład:

int abc(){
    int a = 5
    while((a--) > 0){ // Decrement and comparison both at once
        // Code
    }
}

Mówi, decrement a i uruchom pętlę do czasu a jest większy niż 0

W inny sposób powinno być tak:

int abc() {
    int a = 5;
    while(a > 0) {
        a = a -1 // Decrement inside loop
        // Code
    }
}

(x --> 0) oznacza (x-- > 0).

1. Możesz użyć (x -->)
Output: 9 8 7 6 5 4 3 2 1 0

1. Możesz użyć {[8] }to znaczy (--x > 0)
Output: 9 8 7 6 5 4 3 2 1

1. Możesz użyć

(--\
    \
     x > 0)

Output: 9 8 7 6 5 4 3 2 1

1. Możesz użyć

(\
  \
   x --> 0)

Output: 9 8 7 6 5 4 3 2 1 0

1. Możesz użyć

(\
  \
   x --> 0
          \
           \
            )

Output: 9 8 7 6 5 4 3 2 1 0

1. Możesz również użyć

(
 x 
  --> 
      0
       )

Output: 9 8 7 6 5 4 3 2 1 0

Podobnie można wypróbować wiele metod do wykonania to polecenie pomyślnie.

Tutaj -- jest operatorem unary Post decrement.

 while (x-- > 0) // x goes to 0
 {
     printf("%d ", x);
 }

• na początku warunek będzie oceniany jako (x > 0) // 10 > 0
• teraz, ponieważ warunek jest prawdziwy, przejdzie do pętli ze zmniejszoną wartością x-- // x = 9
• dlatego pierwsza drukowana wartość to 9
• i tak dalej. W ostatniej pętli x=1, więc warunek jest true. Zgodnie z operatorem jednoargumentowym wartość została zmieniona na x = 0 w momencie drukowania.
• Teraz, x = 0, który ocenia warunek (x > 0 ) jako false I while pętla kończy się.

Ten {[0] } w ogóle nie jest operatorem. Mamy operator ->, ale nie -->. Jest to po prostu błędna interpretacja while(x-- >0), co po prostu oznacza, że X ma operator dekrecji post i pętla ta będzie działać, aż będzie większa niż zero .

Innym prostym sposobem napisania tego kodu byłoby while(x--). Pętla while zatrzyma się, gdy otrzyma fałszywy warunek i tutaj jest tylko jeden przypadek, tj. 0. Zatrzyma się więc, gdy wartość x zostanie zmniejszona do zero .

char sep = '\n'  /1\
; int i = 68    /1  \
; while (i  ---      1\
                       \
                       /1/1/1                               /1\
                                                            /1\
                                                            /1\
                                                            /1\
                                                            /1\
                            /           1\
                           /            1 \
                          /             1  \
                         /              1   \
                         /1            /1    \
                          /1          /1      \
                           /1        /1        /1/1> 0) std::cout \
                              <<i<<                               sep;

 std::cout \
           sep

I mamy dla pętla od 67 do 1.