c++ - sintaxis - ¿Por qué sizeof int es incorrecto, mientras que sizeof(int) es correcto?

sizeof en c sintaxis

Question

Sabemos que sizeof es un operador utilizado para calcular el tamaño de cualquier tipo de datos y expresión, y cuando el operando es una expresión, los paréntesis pueden omitirse.

int main()
{
        int a;

        sizeof int;
        sizeof( int );
        sizeof a;
        sizeof( a );

        return 0;
}

el primer uso de sizeof es incorrecto, mientras que otros son correctos.

Cuando se compila con gcc, se mostrará el siguiente mensaje de error:

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

Mi pregunta es por qué el estándar C no permite este tipo de operación. ¿El sizeof int causará ambigüedad?

Answer 1

A partir del estándar C99

6.5.3.4.2
El operador sizeof produce el tamaño (en bytes) de su operando, que puede ser una expresión o el nombre entre paréntesis de un tipo.

En su caso, int no es expresión ni nombre entre paréntesis.

Answer 2

Hay dos formas de utilizar el operador sizeof en C. La sintaxis es la siguiente:

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

Siempre que use un tipo como operando, debe tener el paréntesis, según la definición de sintaxis del idioma. Si usa sizeof en una expresión, no necesita el paréntesis.

El estándar C brinda un ejemplo de dónde puede desear usarlo en una expresión:

sizeof array / sizeof array[0]

Sin embargo, en aras de la coherencia y para evitar errores relacionados con la precedencia del operador, le aconsejo personalmente que siempre use () sin importar la situación.

Answer 3

Lo siguiente podría ser ambiguo:

sizeof int * + 1

¿Es eso (sizeof (int*)) + 1 , o (sizeof(int)) * (+1) ?

Obviamente, el lenguaje C podría haber introducido una regla para resolver la ambigüedad, pero puedo imaginar por qué no se molestó. Con el lenguaje tal como está, un especificador de tipo nunca aparece "desnudo" en una expresión, por lo que no hay necesidad de reglas para resolver si ese segundo * es parte del tipo o un operador aritmético.

La gramática existente ya resuelve la posible ambigüedad de sizeof (int *) + 1 . Es (sizeof(int*))+1 , no sizeof((int*)(+1)) .

C ++ tiene un problema similar para resolver con la sintaxis de conversión de estilo de función. Puede escribir int(0) y puede escribir typedef int *intptr; intptr(0); typedef int *intptr; intptr(0); , pero no puedes escribir int*(0) . En ese caso, la resolución es que el tipo "desnudo" debe ser un nombre de tipo simple, no puede ser simplemente cualquier ID de tipo antiguo que pueda tener espacios en él, o la puntuación final. Tal vez sizeof podría haberse definido con la misma restricción, no estoy seguro.