Что такое оператор >>> = в C?

Заданный коллегой как загадка, я не могу понять, как на самом деле эта C-программа компилируется и работает. Что это за >>>=оператор и странный 1P1литерал? Я тестировал в Clang и GCC. Предупреждений нет и вывод "???"

#include <stdio.h>

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

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

    return 0;
}

Линия:

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

содержит орграфы :> и <:, которые переводят в ]и [соответственно, так что это эквивалентно:

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

Литерал 0xFULLтакой же как 0xF(который является шестнадцатеричным для 15); то ULLпросто указывает , что Это unsigned long longбуквальное . В любом случае, как логическое значение, оно истинно, поэтому 0xFULL ? '\0' : -1оценивается '\0'как символьный литерал , числовое значение которого просто 0.

Между тем, 0X.1P1это шестнадцатеричный литерал с плавающей точкой, равный 2/16 = 0,125. В любом случае, будучи ненулевым, это также верно как логическое значение, поэтому отрицание его дважды с помощью !!снова производит 1. Таким образом, все это упрощается до:

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

Оператор >>=является составным присваиванием, которое сдвигает бит левого операнда вправо на количество битов, заданных правым операндом, и возвращает результат. В этом случае правый операнд a[1]всегда имеет значение 1, поэтому оно эквивалентно:

while( a[0] >>= 1 )

или, что эквивалентно:

while( a[0] /= 2 )

Начальное значение a[0]равно 10. После однократного смещения вправо становится 5, затем (округление вниз) 2, затем 1 и, наконец, 0, после чего цикл заканчивается. Таким образом, тело цикла выполняется три раза.

Это некоторый довольно туманен код с участием диграфов , а именно , <:и :>которые являются альтернативными маркерами для [и ]соответственно. Существует также некоторое использование условного оператора . Также есть оператор сдвига битов , назначение сдвига вправо >>=.

Это более читаемая версия:

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

и еще более читаемая версия, заменяющая выражения в []значениях, для которых они разрешают:

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

Замена a[0]и a[1]их значения должны облегчить понимание того, что делает цикл, то есть эквивалент:

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

который просто выполняет (целочисленное) деление на 2 в каждой итерации, создавая последовательность 5, 2, 1.

Давайте пройдемся по выражению слева направо:

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

Первое, что я заметил, это то, что мы используем троичный оператор от использования ?. Итак, подвыражение:

0xFULL ? '\0' : -1

говорит "если 0xFULLне ноль, возвращайте '\0', в противном случае -1. 0xFULLэто шестнадцатеричный литерал с беззнаковым длинным-длинным суффиксом - это означает, что это шестнадцатеричный литерал типа unsigned long long. Это на самом деле не имеет значения, потому что 0xFможет помещаться внутри обычного целого числа.

Кроме того, троичный оператор преобразует типы второго и третьего членов в их общий тип. '\0'затем преобразуется в int, что просто 0.

Значение 0xFнамного больше нуля, поэтому оно проходит. Выражение теперь становится:

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

Далее :>идет орграф . Это конструкция, которая расширяется до ]:

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

>>=является подписанным оператором сдвига вправо, мы можем выделить его, aчтобы сделать его более понятным.

Кроме того, <:это орграф, который расширяется до [:

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

0X.1P1является шестнадцатеричным литералом с показателем степени. Но независимо от значения, !!все, что не равно нулю, верно. 0X.1P1это 0.125ненулевое значение, поэтому оно становится:

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

Это >>=подписанный оператор правого сдвига. Он изменяет значение своего левого операнда, сдвигая свои биты вперед на значение с правой стороны оператора. 10в двоичном есть 1010. Итак, вот шаги:

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

>>=возвращает результат своей операции, поэтому, пока смещение a[0]остается ненулевым, каждый раз, когда его биты сдвигаются вправо на единицу, цикл будет продолжаться. Четвертая попытка заключается в том, где a[0]делается 0, поэтому цикл никогда не вводится.

В результате ?печатается три раза.