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

Albo za coś zupełnie innego... x przesuwa się 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) {
    // logic
    x = x-1;
}

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

Po prostu przestrzeń sprawia, że rzeczy wyglądają śmiesznie, -- dekrementy 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.

while( x-- > 0 )

Jest jak to jest analizowane.

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

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 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. Dla np.:

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){
        // Code
        a = a -1 // Decrement inside loop
    }
}