Cos'è l'operatore “->” in C ++?

Dopo aver letto funzioni nascoste e angoli bui della C ++ / STL su comp.lang.c++.moderated, ero completamente sorpreso che il seguente frammento compilato e ha lavorato sia in Visual Studio 2008 e G ++ 4.4.

Ecco il codice:

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

Produzione:

9 8 7 6 5 4 3 2 1 0

Suppongo che questo sia C, dal momento che funziona anche in GCC. Da dove viene definito questo standard e da dove proviene?

-->non è un operatore. Sono in effetti due operatori separati --e >.

Il codice del condizionale diminuisce x, restituendo xil valore originale (non decrementato), quindi confronta il valore originale con l' 0utilizzo >dell'operatore.

Per capire meglio, la dichiarazione potrebbe essere scritta come segue:

while( (x--) > 0 )

O per qualcosa di completamente diverso ... x diapositive 0.

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

Non così matematico, ma ... ogni immagine dipinge più di mille parole ...

È un operatore molto complicato, quindi anche ISO / IEC JTC1 (Joint Technical Committee 1) ha inserito la sua descrizione in due diverse parti dello standard C ++.

Scherzi a parte, sono due diversi operatori: --e >descritti rispettivamente in §5.2.6 / 2 e §5.9 della norma C ++ 03.

È equivalente a

while (x-- > 0)

x--(post decremento) equivale a x = x-1così, il codice si trasforma in:

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

x può andare a zero ancora più velocemente nella direzione opposta:

int x = 10;

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

8 6 4 2

Puoi controllare la velocità con una freccia!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

Suo

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

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

Solo lo spazio rende le cose divertenti, --diminuisce e >confronta.

L'uso di -->ha rilevanza storica. Il decremento era (e lo è ancora in alcuni casi), più veloce dell'incremento nell'architettura x86. L'uso -->suggerisce che xsta per farlo 0e fa appello a quelli con background matematici.

while( x-- > 0 )

è come viene analizzato.

Completamente geek, ma userò questo:

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

Un libro che ho letto (non ricordo correttamente quale libro) affermava: i compilatori cercano di analizzare le espressioni con il token più grande usando la regola di destra a sinistra.

In questo caso, l'espressione:

x-->0

Analizza i token più grandi:

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

La stessa regola si applica a questa espressione:

a-----b

Dopo l'analisi:

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

Spero che questo aiuti a comprendere l'espressione complicata ^^

Questo è esattamente lo stesso di

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

per numeri non negativi

Ad ogni modo, ora abbiamo un operatore "va a". "-->"è facile essere ricordato come una direzione, e "mentre x va a zero" è significato-dritto.

Inoltre, è un po 'più efficiente rispetto "for (x = 10; x > 0; x --)"ad alcune piattaforme.

Questo codice confronta prima x e 0 e quindi diminuisce x. (Detto anche nella prima risposta: stai post-decrementando x e quindi confrontando x e 0 con l' >operatore.) Vedi l'output di questo codice:

9 8 7 6 5 4 3 2 1 0

Ora confrontiamo prima e poi diminuiamo vedendo 0 nell'output.

Se vogliamo prima diminuire e poi confrontare, utilizzare questo codice:

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

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

Tale output è:

9 8 7 6 5 4 3 2 1

Il mio compilatore stamperà 9876543210 quando eseguo questo codice.

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

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

Come previsto. In while( x-- > 0 )realtà significa while( x > 0). Il x--post diminuisce x.

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

è un modo diverso di scrivere la stessa cosa.

È bello che l'originale assomigli "mentre x va a 0" però.

Manca uno spazio tra --e >. xviene post decrementato, ovvero decrementato dopo aver verificato la condizione x>0 ?.

--è l' operatore di decremento ed >è l' operatore maggiore di .

I due operatori vengono applicati come uno solo come -->.

È una combinazione di due operatori. Il primo --è per decrementare il valore, e >per verificare se il valore è maggiore dell'operando di destra.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

L'output sarà:

9 8 7 6 5 4 3 2 1 0            

In realtà, xè post-decrementante e con quella condizione viene controllata. Non -->lo è(x--) > 0

Nota: il valore di xviene modificato dopo il controllo della condizione, poiché è in post-decremento. Alcuni casi simili possono anche verificarsi, ad esempio:

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

C e C ++ obbediscono alla regola del "munch massimo". Allo stesso modo in cui a --- b viene tradotto (a--) - b, nel tuo caso si x-->0traduce in (x--)>0.

Ciò che la regola dice essenzialmente è che andando da sinistra a destra, le espressioni si formano prendendo il massimo dei caratteri che formeranno un'espressione valida.

Perché tutta la complicazione?

La semplice risposta alla domanda originale è solo:

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

Fa la stessa cosa. Non dire che dovresti farlo in questo modo, ma fa la stessa cosa e avrebbe risposto alla domanda in un post.

La x--è un sinonimo di quanto sopra, ed >è solo un normale maggiore di operator. Nessun grande mistero!

Ci sono troppe persone che complicano le cose semplici al giorno d'oggi;)

In modo convenzionale definiremmo una condizione tra whileparentesi ad anello ()e una condizione di terminazione all'interno delle parentesi graffe {}, ma -->definiremo entrambe contemporaneamente.

Per esempio:

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

Questo diminuisce aed esegue il ciclo mentre aè maggiore di 0.

Convenzionalmente, sarebbe come:

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

In entrambi i modi, facciamo la stessa cosa e raggiungiamo gli stessi obiettivi.

(x --> 0) si intende (x-- > 0)

1. Puoi usare (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. puoi usare (-- x > 0) È cattivo(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. Puoi usare

(--\
    \
     x > 0)

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

4. Puoi usare

(\
  \
   x --> 0)

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

5. Puoi usare

(\
  \
   x --> 0
          \
           \
            )

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

6. puoi anche usare

(
 x 
  --> 
      0
       )

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

allo stesso modo, puoi provare molti metodi per eseguire correttamente questo comando