Cos'è l'operatore >>> = in C?

Dato da un collega come un enigma, non riesco a capire come questo programma C compili e funzioni. Cos'è questo >>>=operatore e lo strano 1P1letterale? Ho provato a Clang e GCC. Non ci sono avvisi e l'output è "???"

#include <stdio.h>

int main()
{
    int a[2]={ 10, 1 };

    while( a[ 0xFULL?'\0':-1:>>>=a<:!!0X.1P1 ] )
        printf("?");

    return 0;
}

La linea:

while( a[ 0xFULL?'\0':-1:>>>=a<:!!0X.1P1 ] )

contiene i digrafi :> e <:, che si traducono in ]e [rispettivamente, quindi equivalgono a:

while( a[ 0xFULL?'\0':-1 ] >>= a[ !!0X.1P1 ] )

Il letterale 0xFULLè lo stesso di 0xF(che è hex per 15); il ULLgiusto specifica che è unsigned long longletterale . In ogni caso, come booleano è vero, quindi 0xFULL ? '\0' : -1valuta '\0', che è un carattere letterale il cui valore numerico è semplicemente 0.

Nel frattempo, 0X.1P1è un virgola mobile esadecimale letterale pari a 2/16 = 0,125. In ogni caso, essendo diverso da zero, è anche vero come un valore booleano, quindi negarlo due volte con di !!nuovo produce 1. Pertanto, il tutto si semplifica fino a:

while( a[0] >>= a[1] )

L'operatore >>=è un incarico composto che sposta i bit dell'operando di sinistra a destra in base al numero di bit dato dall'operando di destra e restituisce il risultato. In questo caso, l'operando giusto a[1]ha sempre il valore 1, quindi equivale a:

while( a[0] >>= 1 )

o, equivalentemente:

while( a[0] /= 2 )

Il valore iniziale di a[0]è 10. Dopo aver spostato a destra una volta, diventa 5, quindi (arrotondando per difetto) 2, quindi 1 e infine 0, a quel punto il ciclo termina. Pertanto, il corpo del loop viene eseguito tre volte.

È un codice piuttosto oscuro che coinvolge i digrafi , vale a dire <:e :>che sono token alternativi per [e ]rispettivamente. C'è anche un certo uso dell'operatore condizionale . C'è anche un operatore di spostamento dei bit , l'assegnazione del cambio corretta >>=.

Questa è una versione più leggibile:

while( a[ 0xFULL ? '\0' : -1 ] >>= a[ !!0X.1P1 ] )

e una versione ancora più leggibile, sostituendo le espressioni in []per i valori che risolvono per:

while( a[0] >>= a[1] )

Sostituendo a[0]e a[1]per i loro valori dovrebbe essere facile capire cosa sta facendo il loop, cioè l'equivalente di:

int i = 10;
while( i >>= 1)

che sta semplicemente eseguendo una divisione (intera) per 2 in ogni iterazione, producendo la sequenza 5, 2, 1.

Esaminiamo l'espressione da sinistra a destra:

a[ 0xFULL?'\0':-1:>>>=a<:!!0X.1P1 ]

La prima cosa che noto è che stiamo usando l'operatore ternario dall'uso di ?. Quindi la sottoespressione:

0xFULL ? '\0' : -1

sta dicendo "se 0xFULLè diverso da zero, return '\0', altrimenti -1. 0xFULLè un letterale esadecimale con il suffisso long-long senza segno - il che significa che è un letterale esadecimale di tipo unsigned long long. Ciò non ha molta importanza, perché 0xFpuò rientrare in un intero normale.

Inoltre, l'operatore ternario converte i tipi del secondo e terzo termine nel loro tipo comune. '\0'viene quindi convertito in int, che è giusto 0.

Il valore di 0xFè molto più grande di zero, quindi passa. L'espressione ora diventa:

a[ 0 :>>>=a<:!!0X.1P1 ]

Successivamente, :>è un digrafo . È un costrutto che si espande per ]:

a[0 ]>>=a<:!!0X.1P1 ]

>>=è l'operatore di spostamento a destra firmato, possiamo distanziarlo aper renderlo più chiaro.

Inoltre, <:è un digrafo che si espande a [:

a[0] >>= a[!!0X.1P1 ]

0X.1P1è un letterale esadecimale con un esponente. Ma non importa il valore, il valore !!di qualsiasi cosa diversa da zero è vero. 0X.1P1è 0.125che è diverso da zero, quindi diventa:

a[0] >>= a[true]
-> a[0] >>= a[1]

Il >>=è l'operatore spostamento a destra firmato. Cambia il valore dell'operando di sinistra spostando i suoi bit in avanti del valore sul lato destro dell'operatore. 10in binario è 1010. Quindi, ecco i passaggi:

01010 >> 1 == 00101
00101 >> 1 == 00010
00010 >> 1 == 00001
00001 >> 1 == 00000

>>=restituisce il risultato del suo funzionamento, quindi finché lo spostamento a[0]rimane diverso da zero per ogni volta che i suoi bit vengono spostati a destra di uno, il loop continuerà. Il quarto tentativo è dove a[0]diventa 0, quindi il ciclo non viene mai inserito.

Di conseguenza, ?viene stampato tre volte.