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

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.

From C99 Standard

6.5.3.4.2
The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type.

In your case int is neither expression nor parenthesized name.

There are two ways to use the sizeof operator in C. The syntax is this:

C11 6.5.3 Unary operators...sizeof unary-expressionsizeof ( type-name )

Whenever you use a type as operand, you must have the parenthesis, by the syntax definition of the language. If you use sizeof on an expression, you don't need the parenthesis.

The C standard gives one such example of where you might want to use it on an expression:

sizeof array / sizeof array[0]

However, for the sake of consistency, and to avoid bugs related to operator precedence, I would personally advise to always use () no matter the situation.