Why sizeof int is wrong, while sizeof(int) is right?
c, c++, sizeof
Solution
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.
Problem
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?