Co to jest operator „->” w C ++?

Po przeczytaniu ukrytych funkcji i zakamarkach C ++ / STL na comp.lang.c++.moderated, byłem całkowicie zaskoczony, że następujący fragment skompilowany i pracował zarówno w Visual Studio 2008 i G ++ 4.4.

Oto kod:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

Wynik:

9 8 7 6 5 4 3 2 1 0

Zakładam, że to C, ponieważ działa również w GCC. Gdzie jest to zdefiniowane w standardzie i skąd ono pochodzi?

-->nie jest operatorem. W rzeczywistości są to dwa oddzielne operatory --i >.

Kod warunku zmniejsza się x, zwracając xoryginalną (nie zmniejszoną) wartość, a następnie porównuje oryginalną wartość za 0pomocą >operatora.

Aby lepiej zrozumieć, oświadczenie można napisać w następujący sposób:

while( (x--) > 0 )

Lub coś zupełnie innego ... xslajdy do 0.

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

Nie tak matematyczne, ale ... każdy obraz maluje tysiąc słów ...

To bardzo skomplikowany operator, więc nawet ISO / IEC JTC1 (Wspólny Komitet Techniczny 1) umieścił swój opis w dwóch różnych częściach standardu C ++.

Żartuje bok, są to dwie różne operacji: --a >opisane odpowiednio w §5.2.6 / 2 i §5.9 z C ++ 03 standardu.

Jest to równoważne z

while (x-- > 0)

x--(po zmniejszeniu) jest równoważne, x = x-1więc kod przekształca się w:

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

x może zerować nawet 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

;)

Jego

#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ą zabawnie, --dekrety i >porównania.

Zastosowanie -->ma znaczenie historyczne. Zmniejszanie było (i nadal jest w niektórych przypadkach) szybsze niż zwiększanie w architekturze x86. Korzystanie -->sugeruje, że xtak będzie 0, i przemawia do osób z wykształceniem matematycznym.

while( x-- > 0 )

to jest tak parsowane.

Zupełnie maniakiem, ale użyję 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;
}

W jednej książce, którą przeczytałem (nie pamiętam poprawnie, którą książkę) napisałem: Kompilatory próbują parsować wyrażenia do największego tokena przy użyciu reguły lewej i prawej.

W takim przypadku wyrażenie:

x-->0

Analizuje największe tokeny:

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

Ta sama reguła dotyczy 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 jest zapamiętać go jako kierunek, a „gdy x idzie do zera” jest proste w znaczeniu.

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 zmniejsza x. (Powiedział również w pierwszej odpowiedzi: dekrementujesz x, a następnie porównujesz x i 0 z >operatorem). Zobacz wynik tego kodu:

9 8 7 6 5 4 3 2 1 0

Teraz najpierw porównujemy, a następnie zmniejszamy, widząc 0 w danych wyjściowych.

Jeśli chcemy najpierw zmniejszyć, 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;
}

Ten wynik to:

9 8 7 6 5 4 3 2 1

Mój kompilator wydrukuje 9876543210 po uruchomieniu tego kodu.

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

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

Zgodnie z oczekiwaniami. W while( x-- > 0 )rzeczywistości oznacza while( x > 0). x--Postu zmniejsza x.

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

to inny sposób pisania tego samego.

Fajnie, że oryginał wygląda jak „podczas gdy x idzie do 0”.

Brakuje miejsca między --i >. xjest po zmniejszeniu, to znaczy zmniejszeniu po sprawdzeniu warunku x>0 ?.

--jest operatorem dekrementacji i >jest operatorem większym niż .

Oba operatory są stosowane jako jeden podobny -->.

To połączenie dwóch operatorów. Pierwszy --służy do zmniejszania wartości i >do sprawdzania, czy wartość jest większa niż operand po prawej stronie.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

Dane wyjściowe będą:

9 8 7 6 5 4 3 2 1 0            

W rzeczywistości xjest po dekrementacji iz tym warunkiem jest sprawdzany. Nie -->jest(x--) > 0

Uwaga: wartość parametru xzmienia się po sprawdzeniu warunku, ponieważ zmniejsza się on po dekrementacji. Mogą wystąpić również podobne przypadki, na przykład:

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

C i C ++ przestrzegają zasady „maksymalnego chrupania”. Taki sam sposób, w jaki a --- b jest tłumaczony (a--) - b, w twoim przypadku x-->0oznacza (x--)>0.

Zasada mówi w zasadzie, że od lewej do prawej, wyrażenia są tworzone przez wzięcie maksymalnej liczby znaków, które utworzą prawidłowe wyrażenie.

Skąd ta komplikacja?

Prosta odpowiedź na pierwotne pytanie brzmi:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x > 0) 
    {
        printf("%d ", x);
        x = x-1;
    }
}

Robi to samo. Nie mówię, że powinieneś to zrobić w ten sposób, ale robi to samo i odpowiedziałby na pytanie w jednym poście.

Jest x--to po prostu skrót od powyższego, i >jest po prostu normą większą niż operator. Bez wielkiej tajemnicy!

Zbyt wielu ludzi komplikuje proste rzeczy;)

W konwencjonalny sposób zdefiniowalibyśmy warunek w whilenawiasie pętli ()i warunek kończący w nawiasach {}, ale -->definiujemy oba jednocześnie.

Na przykład:

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

To zmniejsza ai uruchamia pętlę, gdy ajest większa niż 0.

Konwencjonalnie wyglądałoby to tak:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

Oba sposoby robimy to samo i osiągamy te same cele.

(x --> 0) znaczy (x-- > 0)

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

2. możesz użyć (-- x > 0) To znaczy(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. możesz użyć

(--\
    \
     x > 0)

output -: 9 8 7 6 5 4 3 2 1

4. możesz użyć

(\
  \
   x --> 0)

output -: 9 8 7 6 5 4 3 2 1 0

5. możesz użyć

(\
  \
   x --> 0
          \
           \
            )

output -: 9 8 7 6 5 4 3 2 1 0

6. możesz także użyć

(
 x 
  --> 
      0
       )

output -: 9 8 7 6 5 4 3 2 1 0

podobnie możesz wypróbować wiele metod, aby pomyślnie wykonać to polecenie