Why does sizeof(my_arr)[0] compile and equal sizeof(my_arr[0])?

Question

Why does this code compile?

_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, "");

The first 2 asserts are obviously correct, but I would have expected the last line to fail, as my understanding is that sizeof() should evaluate to an integer literal, which can't be treated as an array. In other words, it would fail in the same way that the following line fails:

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

Interestingly, the following does indeed fail to compile (which should be doing the same thing, no?):

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

error: invalid type argument of unary '*' (have 'long unsigned int') _Static_assert(*sizeof(my_arr) == 4, "");

If it matters, I'm using gcc 5.3.0

A recent duplicate has another variation on this syntax surprise: [Why does sizeof(x)++ compile?](https://stackoverflow.com/q/61663807) — Peter Cordes, May 08 '20 at 02:34

melpomene · Accepted Answer · 2017-10-09T19:28:34.590

198

sizeof is not a function. It's a unary operator like ! or ~.

sizeof(my_arr)[0] parses as sizeof (my_arr)[0], which is just sizeof my_arr[0] with redundant parentheses.

This is just like !(my_arr)[0] parses as !(my_arr[0]).

In general, postfix operators have higher precedence than prefix operators in C. sizeof *a[i]++ parses as sizeof (*((a[i])++)) (the postfix operators [] and ++ are applied to a first, then the prefix operators * and sizeof).

(This is the expression version of sizeof. There's also a type version, which takes a parenthesized type name: sizeof (TYPE). In that case the parens would be required and part of the sizeof syntax.)

edited Oct 09 '17 at 19:28

answered Oct 09 '17 at 19:12

melpomene

84,125
8
85
148

14

I definitely knew that sizeof was a unary operator and not a function, but totally forgot. Woops. Thanks for the detailed explanation. The fact that [] is higher precedence than * is interesting regardless. – bgomberg Oct 09 '17 at 20:41
@melpomene Interesting. I've never thought of `sizeof` being a unary operator. – mutantkeyboard Oct 10 '17 at 14:03
6

Don't you mean `"... parses as sizeof (my_arr[0])"`? Just adding a space doesn't really change anything. – Bernhard Barker Oct 11 '17 at 02:37
I would recommend `sizeof((my_array)[0])` instead – bolov Oct 14 '17 at 13:59
[Why is sizeof considered an operator?](https://stackoverflow.com/q/1393582/995714) – phuclv Sep 23 '18 at 13:17

AnT stands with Russia · Answer 2 · 2017-10-09T19:24:32.453

sizeof has two "versions": sizeof(type name) and sizeof expression. The former requires a pair of () around its argument. But the latter - the one with an expression as an argument - does not have () around its argument. Whatever () you use in the argument is seen as part of the argument expression, not part of sizeof syntax itself.

Since my_arr is known to the compiler as an object name, not a type name, your sizeof(my_arr)[0] is actually seen by the compiler as sizeof applied to an expression: sizeof (my_arr)[0], where (my_arr)[0] is the argument expression. The () surrounding the array name is purely superfluous. The whole expression is interpreted as sizeof my_arr[0]. This is equivalent to your previous sizeof(my_arr[0]).

(This means, BTW, that your previous sizeof(my_arr[0]) also contains a pair of superfluous ().)

It is a rather widespread misconception that sizeof's syntax somehow requires a pair of () around its argument. This misconception is what misleads people's intuition when interpreting such expressions as sizeof(my_arr)[0].

The first version exists so that you can check the size of an integer in general on the machine (from back when there weren't even 64-bit machines!), but `int` isn't a valid expression, so you can't use the second form with it. — NH., Oct 10 '17 at 15:46

mch · Answer 3 · 2017-10-09T19:17:35.260

27

[] have a higher precendence than sizeof. So sizeof(my_arr)[0] is the same as sizeof((my_arr)[0]).

Here is a link to a precedence table.

edited Oct 09 '17 at 19:17

answered Oct 09 '17 at 19:12

mch

9,424
2
28
42

score 8 · Answer 4 · answered Oct 09 '17 at 19:13

8

You're using the version of the sizeof operator that takes an expression as parameter. Unlike the one that takes a type, it doesn't require parentheses. Hence, the operand is simply (my_arr)[0], with the parentheses being redundant.

answered Oct 09 '17 at 19:13

Quentin

62,093
7
131
191

Why does sizeof(my_arr)[0] compile and equal sizeof(my_arr[0])?

4 Answers4

Linked