O que é o operador >>> = em C?

Dado por um colega como um quebra-cabeça, não consigo descobrir como esse programa C realmente compila e executa. O que é esse >>>=operador e o 1P1literal estranho ? Eu testei em Clang e GCC. Não há avisos e a saída é "???"

#include <stdio.h>

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

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

    return 0;
}

A linha:

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

contém os digrafos :> e <:, que se traduzem para ]e [respectivamente, portanto, é equivalente a:

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

O literal 0xFULLé o mesmo que 0xF(que é hexadecimal para 15); o ULLjust especifica que é um unsigned long longliteral . De qualquer forma, como booleano é verdade, é 0xFULL ? '\0' : -1avaliado como '\0', que é um literal de caractere cujo valor numérico é simplesmente 0.

Enquanto isso, 0X.1P1é um literal de ponto flutuante hexadecimal igual a 2/16 = 0,125. De qualquer forma, sendo diferente de zero, também é verdadeiro como um booleano, portanto, negá-lo duas vezes com !!novamente produz 1. Assim, tudo simplifica:

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

O operador >>=é uma atribuição composta que desloca o operando esquerdo para a direita pelo número de bits fornecido pelo operando direito e retorna o resultado. Nesse caso, o operando certo a[1]sempre tem o valor 1, portanto é equivalente a:

while( a[0] >>= 1 )

ou equivalente:

while( a[0] /= 2 )

O valor inicial de a[0]é 10. Depois de mudar para a direita uma vez, torna-se 5, depois (arredondando para baixo) 2, depois 1 e finalmente 0, altura em que o loop termina. Assim, o corpo do loop é executado três vezes.

É um código bastante obscuro que envolve dígrafos , a saber, <:e :>que são tokens alternativos para [e ]respectivamente. Também há algum uso do operador condicional . Há também um operador de troca de marchas, a atribuição de troca certa >>=.

Esta é uma versão mais legível:

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

e uma versão ainda mais legível, substituindo as expressões no []pelos valores que eles resolvem:

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

A substituição a[0]e a[1]por seus valores deve facilitar a compreensão do que o loop está fazendo, ou seja, o equivalente a:

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

que está simplesmente executando a divisão (inteira) por 2 em cada iteração, produzindo a sequência 5, 2, 1.

Vamos passar pela expressão da esquerda para a direita:

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

A primeira coisa que noto é que estamos usando o operador ternário do uso de ? . Então a subexpressão:

0xFULL ? '\0' : -1

está dizendo "se 0xFULLfor diferente de zero, retorne '\0', caso contrário -1. 0xFULLé um literal hexadecimal com o sufixo longo não assinado - o que significa que é um literal hexadecimal do tipo unsigned long long. Isso realmente não importa, porque 0xFpode caber dentro de um número inteiro regular.

Além disso, o operador ternário converte os tipos do segundo e do terceiro termos no tipo comum. '\0'é então convertido para int, o que é justo 0.

O valor de 0xFé muito maior que zero, então passa. A expressão agora se torna:

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

Em seguida, :>é um dígrafo . É uma construção que se expande para ]:

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

>>=é o operador de turno certo assinado, podemos separá-lo apara torná-lo mais claro.

Além disso, <:é um dígrafo que se expande para [:

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

0X.1P1é um literal hexadecimal com um expoente. Mas não importa o valor, o valor !!de qualquer coisa que não seja zero é verdadeiro. 0X.1P1é 0.125que é diferente de zero, então ele se torna:

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

O >>=é o operador de turno certo assinado. Ele altera o valor do seu operando esquerdo, deslocando seus bits para a frente pelo valor no lado direito do operador. 10em binário é 1010. Então, aqui estão as etapas:

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

>>=retorna o resultado de sua operação, desde que o deslocamento a[0]permaneça diferente de zero para cada vez que seus bits forem deslocados para a direita em um, o loop continuará. A quarta tentativa é ondea[0] fica 0, então o loop nunca é inserido.

Como resultado, ?é impresso três vezes.