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




code-formatting standards-compliance (18)

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?


Answers

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


È una combinazione di due operatori. Primo -- serve 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            

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

Questo codice confronta prima x e 0 e quindi decrementa x. (Anche detto nella prima risposta: stai post-decrementando x e poi confronti x e 0 con l'operatore > .) Vedi l'output di questo codice:

9 8 7 6 5 4 3 2 1 0

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

Se vogliamo prima decrementare e quindi confrontare, usa questo codice:

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

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

Quell'output è:

9 8 7 6 5 4 3 2 1

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

C'è uno spazio mancante tra -- e > . x è post decrementato, cioè decrementato dopo aver controllato la condizione 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

;)


while( x-- > 0 )

è come viene analizzato.


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.


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

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


C e C++ obbediscono alla regola del "massimo sgranocchiare". (a--) - b stesso modo a --- b è tradotto in (a--) - b , nel tuo caso x-->0 traduce in (x--)>0 .

Quello che la regola dice in sostanza è che andando da sinistra a destra, le espressioni si formano prendendo il massimo di caratteri che formeranno un'espressione valida.


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 ...


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".


Questo è esattamente lo stesso di

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

per numeri non negativi


Perché tutte le complicazioni?

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 dicendo che dovresti farlo in questo modo, ma fa la stessa cosa e avrebbe risposto alla domanda in un solo post.

La x-- è semplicemente una scorciatoia per quanto sopra, e > è solo un normale operator maggiore di. Nessun grande mistero!

Ci sono troppe persone che rendono semplici le cose semplici oggigiorno;)


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 > .


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)

L'operatore condizionale ternario consente semplicemente di testare una condizione in una singola riga sostituendo la multilinea if-else rendendo il codice compatto.

Sintassi:

[on_true] if [expression] else [on_false]

1- Metodo semplice per utilizzare l'operatore ternario:

# Program to demonstrate conditional operator
a, b = 10, 20
# Copy value of a in min if a < b else copy b
min = a if a < b else b
print(min)  # Output: 10

2- Metodo diretto di utilizzo di tuple, dizionario e lambda:

# Python program to demonstrate ternary operator
a, b = 10, 20
# Use tuple for selecting an item
print( (b, a) [a < b] )
# Use Dictionary for selecting an item
print({True: a, False: b} [a < b])
# lamda is more efficient than above two methods
# because in lambda  we are assure that
# only one expression will be evaluated unlike in
# tuple and Dictionary
print((lambda: b, lambda: a)[a < b]()) # in output you should see three 10

3- L'operatore Ternario può essere scritto come nidificato se-else:

# Python program to demonstrate nested ternary operator
a, b = 10, 20
print ("Both a and b are equal" if a == b else "a is greater than b"
        if a > b else "b is greater than a")

L'approccio sopra può essere scritto come:

# Python program to demonstrate nested ternary operator
a, b = 10, 20
if a != b:
    if a > b:
        print("a is greater than b")
    else:
        print("b is greater than a")
else:
    print("Both a and b are equal") 
# Output: b is greater than a




c++ operators code-formatting standards-compliance