C'deki >>> = operatörü nedir?

Bir meslektaşım tarafından bir bulmaca olarak verildiğinde, bu C programının aslında nasıl derlendiğini ve çalıştığını anlayamıyorum. Bu >>>=operatör ve garip 1P1gerçek nedir? Clang ve GCC'de test yaptım. Hiçbir uyarı yok ve çıktı "???"

#include <stdio.h>

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

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

    return 0;
}

Çizgi:

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

içeren digraphs :> ve <:çevirmek, ]ve [bu yüzden eşdeğer olduğunu, sırasıyla:

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

Değişmez 0xFULLdeğer 0xF(ile onaltılık olan 15) ile aynıdır ; ULLbu sadece belirtir bir var unsigned long longdeğişmezi . Böylece herhangi bir durumda, boolean olarak bu doğrudur 0xFULL ? '\0' : -1değerlendirir için '\0'bir olan karakter değişmezi basitçe kimin sayısal değer 0.

Bu arada, 0X.1P1a, değişmez onaltılık kayan nokta 2/16 = 0.125 oranları ile aynıdır. Her durumda, sıfırdan farklı olarak, bir boolean olarak da doğrudur, bu yüzden !!tekrar iki kez reddetmek üretir 1. Böylece, her şey basitleşir:

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

Operatör >>=, sol işlenenini sağ işlenen tarafından verilen bit sayısına göre bitiren ve sonucu döndüren bileşik bir atamadır . Bu durumda, sağ işlenen a[1]her zaman değere sahiptir 1, bu nedenle:

while( a[0] >>= 1 )

Veya eşdeğer olarak:

while( a[0] /= 2 )

Başlangıç ​​değeri a[0]10'dur. Sağa kaydırıldıktan sonra 5 olur, sonra (aşağı yuvarlanır) 2, sonra 1 ve son olarak 0 olur, bu noktada döngü sona erer. Böylece, döngü gövdesi üç kez yürütülür.

Bu içeren bazı oldukça belirsiz kod digraphs yani, <:ve :>alternatif belirteçleri olan [ve ]sırasıyla. Koşullu operatörün de bazı kullanımları vardır . Ayrıca biraz vites operatörü , sağ vardiya ataması da var >>=.

Bu daha okunabilir bir versiyon:

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

ve daha da okunabilir bir sürüm olarak, çözümledikleri []değerler için ifadeleri değiştirerek :

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

Değiştirmek a[0]ve a[1]değerleri için, döngünün ne yaptığını, yani aşağıdakilerin eşdeğerini bulmayı kolaylaştıracaktır:

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

bu, her bir yinelemede basitçe (tamsayı) bölünmeyi gerçekleştirerek diziyi üretir 5, 2, 1.

Soldan sağa ifadesini inceleyelim:

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

Fark ettiğim ilk şey, üçlü operatör kullanmanın kullanılmasıdır ?. Yani alt ifade:

0xFULL ? '\0' : -1

eğer" söylediğini 0xFULLsıfırdan, dönüş olduğunu '\0'aksi takdirde -1. 0xFULLile onaltılık değişmezi olan işaretsiz uzun uzun sonek - bu tip bir onaltılık değişmezi olduğu anlamına unsigned long longçünkü, gerçekten önemli olsa değildir. 0xFDüzenli tamsayı içine sığabilir.

Ayrıca, üçlü operatör ikinci ve üçüncü terimlerin türlerini ortak türlerine dönüştürür. '\0'sonra dönüştürülür int, sadece 0.

Değeri 0xFsıfırdan çok daha büyük, bu yüzden geçiyor. İfade şimdi:

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

Sonra, :>bir digraf . Aşağıdakilere genişleyen bir yapıdır ]:

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

>>=imzalı sağ vardiya operatörü, adaha net hale getirmek için bunu boşluk bırakabiliriz .

Dahası, <:aşağıdakilere genişleyen bir digraftır [:

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

0X.1P1bir üssü olan onaltılık bir değişmez değerdir. Ama değer ne olursa olsun, !!sıfır olmayan herhangi bir şey doğrudur. 0X.1P1bir 0.125hale gelir, böylece sıfır olmayan, aşağıdakilerden biridir:

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

>>=İmzalı sağa kaydırma operatörüdür. Sol işleneninin değerini, operatörün sağ tarafındaki değerle ileri doğru kaydırarak değiştirir. 10ikili 1010. İşte adımlar:

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

>>=a[0], bitlerinin her bir sağa kaydırıldığı her defasında sıfırdan farklı kaldığı sürece, işlemin sonucunu döndürür, döngü devam eder. Dördüncü girişim nerede a[0]olur 0, bu yüzden döngü asla girilmez.

Sonuç olarak, ?üç kez yazdırılır.