bitwise - Qual è l'operatore "->" in C++?




operator in c (14)

Dopo aver letto Hidden Features e Dark Corners di C ++ / STL su comp.lang.c++.moderated , sono rimasto completamente sorpreso dal fatto che il seguente snippet fosse compilato e funzionasse sia in Visual Studio 2008 che in G ++ 4.4.

Ecco il codice:

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

Presumo che questo sia C, visto che funziona anche in GCC. Dove è definito nello standard e da dove proviene?

https://code.i-harness.com


Fai attenzione

--> non è un operatore. Sono infatti due operatori separati, -- e > .

Il codice condizionale decrementa x , mentre restituisce il valore originale (non decrementato) di x , quindi confronta il valore originale con 0 usando l'operatore > .

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

while((x--) > 0)

È equivalente a

while (x-- > 0)

x-- (post decremento) è equivalente a x = x-1 quindi, il codice si trasforma in:

while(x > 0) {
    x = x-1;
    // logic
}

Ad ogni modo, abbiamo un operatore "va a" ora. "-->" è facile da ricordare come una direzione e "mentre x va a zero" ha un significato diretto.

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


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

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. Il while( x-- > 0 ) realtà significa while( x > 0) . Il x-- post decrementa x .

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

è un modo diverso di scrivere la stessa cosa

È bello che l'originale abbia l'aspetto di "mentre x va a 0".


In realtà, x è post-decremento e con quella condizione viene controllato. Non è --> , è (x--) > 0

Nota: il valore di x viene modificato dopo che la condizione è stata verificata, in quanto post-decremento. Alcuni casi simili possono anche verificarsi, ad esempio:

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

Modo convenzionale definiamo la condizione in while parentesi di ciclo " () " e terminando la condizione all'interno delle parentesi " {} ", ma questo -- & > è un modo in cui uno definisce tutto in una volta. Ad esempio:

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

Dice, decrementa a ed esegue il ciclo fino al momento in cui a è maggiore di 0

In un altro modo avrebbe dovuto essere come:

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

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


O per qualcosa di completamente diverso ... x fa scorrere a 0

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

Non così matematico, ma ... ogni immagine dipinge un migliaio di parole ...


Questo è esattamente lo stesso di

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

per numeri non negativi


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

A parte gli scherzi, sono due operatori diversi: -- e > descritti rispettivamente in §5.2.6 / 2 e §5.9 dello standard C ++ 03.


Suo

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

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

       printf("%d ", x);
     }

     return 0;
}

Proprio lo spazio fa sembrare le cose divertenti, -- decrementi e confronti > .


Un libro che ho letto (non ricordo correttamente quale libro) ha dichiarato: I compilatori cercano di analizzare le espressioni per il token più grande usando la regola left right.

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 capire l'espressione complicata ^^


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

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


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

;)







standards-compliance