Perché sizeof (my_arr) [0] viene compilato e uguale sizeof (my_arr [0])?

Perché viene compilato questo codice?

_Static uint32_t my_arr[2];
_Static_assert(sizeof(my_arr) == 8, "");
_Static_assert(sizeof(my_arr[0]) == 4, "");
_Static_assert(sizeof(my_arr)[0] == 4, "");

I primi 2 assertori sono ovviamente corretti, ma mi sarei aspettato che l'ultima riga fallisse, poiché la mia comprensione è che sizeof()dovrebbe valutare un valore intero letterale, che non può essere trattato come un array. In altre parole, fallirebbe nello stesso modo in cui fallisce la seguente riga:

_Static_assert(4[0] == 4, "");

È interessante notare che il seguente non riesce a compilare (che dovrebbe fare la stessa cosa, no?):

_Static_assert(*sizeof(my_arr) == 4, "");

errore: argomento di tipo non valido di unario '*' (avere 'long unsigned int') _Static_assert (* sizeof (my_arr) == 4, "");

Se è importante, sto usando gcc 5.3.0

sizeofnon è una funzione. È un operatore unario come !o ~.

sizeof(my_arr)[0]analizza come sizeof (my_arr)[0], che è solo sizeof my_arr[0]con parentesi ridondanti.

Questo è proprio come l' !(my_arr)[0]analisi !(my_arr[0]).

In generale, gli operatori postfix hanno una precedenza maggiore rispetto agli operatori prefissi in C. sizeof *a[i]++analizza come sizeof (*((a[i])++))(gli operatori postfix []e ++vengono applicati aprima agli operatori, quindi agli operatori prefisso *e sizeof).

(Questa è la versione dell'espressione di sizeof. Esiste anche una versione di tipo, che prende un nome di tipo tra parentesi:. sizeof (TYPE)In tal caso, le parentesi verrebbero richieste e parte della sizeofsintassi.)

sizeofha due "versioni": sizeof(type name)e sizeof expression. Il primo richiede un paio di ()argomenti. Ma quest'ultimo - quello con un'espressione come argomento - non ha ()attorno al suo argomento. Qualunque cosa ()tu usi nell'argomento è vista come parte dell'espressione dell'argomento, non come parte della sizeofsintassi stessa.

Poiché my_arrè noto al compilatore come un nome di oggetto, non un nome di tipo, sizeof(my_arr)[0]il compilatore viene effettivamente visto come sizeofapplicato a un'espressione:, sizeof (my_arr)[0]dove (my_arr)[0]è l'espressione dell'argomento. Il ()nome dell'array circostante è puramente superfluo. L'intera espressione è interpretata come sizeof my_arr[0]. Questo è equivalente al tuo precedente sizeof(my_arr[0]).

(Questo significa, a proposito, che il tuo precedente sizeof(my_arr[0])contiene anche una coppia di superfluo ().)

È un'idea sbagliata piuttosto diffusa che sizeofla sintassi in qualche modo richiede un paio di ()argomenti. Questo malinteso è ciò che induce in errore l'intuizione delle persone quando interpretano espressioni come sizeof(my_arr)[0].

[]hanno una precendenza più alta di sizeof. Quindi sizeof(my_arr)[0]è lo stesso di sizeof((my_arr)[0]).

Ecco un collegamento a una tabella di precedenza.

Stai utilizzando la versione sizeofdell'operatore che accetta un'espressione come parametro. A differenza di quello che accetta un tipo, non richiede parentesi. Quindi, l'operando è semplicemente (my_arr)[0], con le parentesi ridondanti.