Why sizeof int is wrong, while sizeof(int) is right?

Question

We know that sizeof is an operator used for calculating the size of any datatype and expression, and when the operand is an expression, the parentheses can be omitted.

int main() {         int a;          sizeof int;         sizeof( int );         sizeof a;         sizeof( a );          return 0; } 

the first usage of sizeof is wrong, while others are right.

When it is compiled using gcc, the following error message will be given:

main.c:5:9: error: expected expression before ‘int’ 

My question is why the C standard does not allow this kind of operation. Will sizeof int cause any ambiguity?

Answer 1

The following could be ambiguous:

sizeof int * + 1 

Is that (sizeof (int*)) + 1, or (sizeof(int)) * (+1)?

Obviously the C language could have introduced a rule to resolve the ambiguity, but I can imagine why it didn't bother. With the language as it stands, a type specifier never appears "naked" in an expression, and so there is no need for rules to resolve whether that second * is part of the type or an arithmetic operator.

The existing grammar does already resolve the potential ambiguity of sizeof (int *) + 1. It is (sizeof(int*))+1, not sizeof((int*)(+1)).

C++ has a somewhat similar issue to resolve with function-style cast syntax. You can write int(0) and you can write typedef int *intptr; intptr(0);, but you can't write int*(0). In that case, the resolution is that the "naked" type must be a simple type name, it can't just be any old type id that might have spaces in it, or trailing punctuation. Maybe sizeof could have been defined with the same restriction, I'm not certain.