¿Cuál es el operador >>> = en C?

Dado por un colega como un rompecabezas, no puedo entender cómo este programa C realmente compila y se ejecuta. ¿Qué es este >>>=operador y el extraño 1P1literal? He probado en Clang y GCC. No hay advertencias y la salida es "???"

#include <stdio.h>

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

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

    return 0;
}

La línea:

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

contiene los dígrafos :> y <:, que se traducen a ]y [respectivamente, por lo que es equivalente a:

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

El literal 0xFULLes el mismo que 0xF(que es hexadecimal 15); el ULLsolo especifica que es un unsigned long longliteral . En cualquier caso, como booleano es cierto, así se 0xFULL ? '\0' : -1evalúa como '\0', que es un carácter literal cuyo valor numérico es simplemente 0.

Mientras tanto, 0X.1P1es un literal de coma flotante hexadecimal igual a 2/16 = 0.125. En cualquier caso, al ser distinto de cero, también es cierto como un booleano, por lo que negarlo dos veces con !!nuevamente produce 1. Por lo tanto, todo se simplifica a:

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

El operador >>=es una asignación compuesta que desplaza su operando izquierdo hacia la derecha por el número de bits dados por el operando derecho y devuelve el resultado. En este caso, el operando correcto a[1]siempre tiene el valor 1, por lo que es equivalente a:

while( a[0] >>= 1 )

o equivalente:

while( a[0] /= 2 )

El valor inicial de a[0]es 10. Después de desplazarse a la derecha una vez, se convierte en 5, luego (redondeando hacia abajo) 2, luego 1 y finalmente 0, en cuyo punto finaliza el ciclo. Por lo tanto, el cuerpo del bucle se ejecuta tres veces.

Es un código bastante oscuro que involucra dígrafos , a saber, <:y :>que son tokens alternativos para [y ]respectivamente. También hay algún uso del operador condicional . También hay un operador de desplazamiento leve , la asignación de desplazamiento correcta >>=.

Esta es una versión más legible:

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

y una versión aún más legible, reemplazando las expresiones en []los valores por los que resuelven:

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

Reemplazar a[0]y a[1]por sus valores debería facilitar la comprensión de lo que está haciendo el ciclo, es decir, el equivalente de:

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

que simplemente realiza la división (entera) por 2 en cada iteración, produciendo la secuencia 5, 2, 1.

Veamos la expresión de izquierda a derecha:

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

Lo primero que noto es que estamos usando el operador ternario del uso de ?. Entonces la subexpresión:

0xFULL ? '\0' : -1

dice "si 0xFULLno es cero, return '\0', de lo contrario -1. 0xFULLes un literal hexadecimal con el sufijo largo largo sin signo , lo que significa que es un literal hexadecimal de tipo unsigned long long. Sin embargo, eso realmente no importa, porque 0xFpuede caber dentro de un entero regular.

Además, el operador ternario convierte los tipos del segundo y tercer término a su tipo común. '\0'luego se convierte a int, que es justo 0.

El valor de 0xFes mucho mayor que cero, por lo que pasa. La expresión ahora se convierte en:

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

A continuación, :>hay un dígrafo . Es una construcción que se expande a ]:

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

>>=es el operador de desplazamiento a la derecha firmado, podemos espaciarlo apara aclararlo.

Además, <:es un dígrafo que se expande a [:

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

0X.1P1es un literal hexadecimal con un exponente. Pero no importa el valor, !!todo lo que no sea cero es cierto. 0X.1P1es 0.125que no es cero, por lo que se convierte en:

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

El >>=es el operador de desplazamiento a la derecha firmado. Cambia el valor de su operando izquierdo desplazando sus bits hacia adelante por el valor en el lado derecho del operador. 10en binario es 1010. Así que aquí están los pasos:

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

>>=devuelve el resultado de su operación, de modo que mientras el desplazamiento a[0]permanezca distinto de cero por cada vez que sus bits se desplacen uno a la derecha, el bucle continuará. El cuarto intento es donde se a[0]hace 0, por lo que el ciclo nunca se ingresa.

Como resultado, ?se imprime tres veces.