Was ist der >>> = Operator in C?

Von einem Kollegen als Puzzle gegeben, kann ich nicht herausfinden, wie dieses C-Programm tatsächlich kompiliert und ausgeführt wird. Was ist dieser >>>=Operator und das seltsame 1P1Literal? Ich habe in Clang und GCC getestet. Es gibt keine Warnungen und die Ausgabe ist "???"

#include <stdio.h>

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

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

    return 0;
}

Die Linie:

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

enthält die Digraphen :> und <:, die übersetzen , ]und die [jeweils so ist es äquivalent zu:

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

Das Literal 0xFULList dasselbe wie 0xF(was hexadezimal ist 15); Das gibt ULLnur an, dass es ein unsigned long longLiteral ist . In jedem Fall ist es als Boolescher Wert wahr, also wird 0xFULL ? '\0' : -1ausgewertet '\0', was ein Zeichenliteral ist, dessen numerischer Wert einfach ist 0.

Inzwischen 0X.1P1ist ein hexadezimales Gleitkomma-Literal gleich 2/16 = 0,125. Da es nicht Null ist, gilt es in jedem Fall auch als Boolescher Wert. Wenn Sie es also zweimal negieren, wird es !!erneut erzeugt 1. Somit vereinfacht sich das Ganze bis auf:

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

Der Operator >>=ist eine zusammengesetzte Zuweisung , die ihren linken Operanden um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschiebt und das Ergebnis zurückgibt. In diesem Fall hat der richtige Operand a[1]immer den Wert 1, also entspricht er:

while( a[0] >>= 1 )

oder gleichwertig:

while( a[0] /= 2 )

Der Anfangswert von a[0]ist 10. Nach einmaligem Verschieben nach rechts wird er zu 5, dann (abgerundet) zu 2, dann zu 1 und schließlich zu 0, an welchem ​​Punkt die Schleife endet. Somit wird der Schleifenkörper dreimal ausgeführt.

Es ist ein ziemlich dunkler Code, der Digraphen enthält , nämlich <:und :>die alternative Token für [bzw. ]sind. Es gibt auch eine Verwendung des bedingten Operators . Es gibt auch einen Bitverschiebungsoperator , die richtige Verschiebungszuordnung >>=.

Dies ist eine besser lesbare Version:

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

und eine noch besser lesbare Version, die die Ausdrücke in []den Werten ersetzt, in die sie aufgelöst werden:

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

Das Ersetzen a[0]und a[1]für ihre Werte sollte es einfach machen, herauszufinden, was die Schleife tut, dh das Äquivalent von:

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

Dies führt einfach eine (ganzzahlige) Division durch 2 in jeder Iteration durch, wodurch die Sequenz erzeugt wird 5, 2, 1.

Lassen Sie uns den Ausdruck von links nach rechts durchgehen:

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

Das erste, was mir auffällt, ist, dass wir den ternären Operator aus der Verwendung von verwenden ?. Also der Unterausdruck:

0xFULL ? '\0' : -1

sagt: "Wenn 0xFULLnicht Null ist, geben Sie '\0'andernfalls zurück -1. 0xFULList ein hexadezimales Literal mit dem vorzeichenlosen Long-Long-Suffix - was bedeutet, dass es ein hexadezimales Literal vom Typ ist unsigned long long. Das ist jedoch nicht wirklich wichtig, da 0xFes in eine reguläre Ganzzahl passen kann.

Außerdem konvertiert der ternäre Operator die Typen des zweiten und dritten Terms in ihren gemeinsamen Typ. '\0'wird dann konvertiert int, was gerecht ist 0.

Der Wert von 0xFist viel größer als Null, also geht er vorbei. Der Ausdruck wird jetzt:

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

Als nächstes :>ist ein Digraph . Es ist ein Konstrukt, das sich erweitert zu ]:

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

>>=ist der signierte Rechtsschichtbetreiber, wir können das ausräumen a, um es klarer zu machen.

Darüber hinaus <:ist ein Digraph, der sich erweitert zu [:

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

0X.1P1ist ein hexadezimales Literal mit einem Exponenten. Aber egal welcher Wert, !!alles, was nicht Null ist, ist wahr. 0X.1P1ist 0.125was nicht Null ist, also wird es:

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

Das >>=ist der signierte Rechtsschichtbetreiber. Es ändert den Wert seines linken Operanden, indem es seine Bits um den Wert auf der rechten Seite des Operators nach vorne verschiebt. 10in binär ist 1010. Also hier sind die Schritte:

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

>>=Gibt das Ergebnis seiner Operation zurück. Solange die Verschiebung a[0]für jedes Mal, wenn ihre Bits um eins nach rechts verschoben werden, ungleich Null bleibt, wird die Schleife fortgesetzt. Der vierte Versuch ist, wo a[0]wird 0, so dass die Schleife nie betreten wird.

Infolgedessen ?wird dreimal gedruckt.