Est-ce que sizeof(int()) est une expression légale ?

Question

Cette question est inspirée par Est-ce que sizeof(void()) est une expression légale ? mais avec une différence importante, expliquée ci-dessous.

L'expression en question est :

sizeof( int() )

Dans la grammaire C++, il apparaît :

expression unaire :

• sizeof Expression unaire
• sizeof ( type-id )

cependant, ( int() ) peut correspondre à ces deux cas de figure avec des significations différentes :

• En tant que Expression unaire il s'agit d'une valeur initialisée int prvalue, entourée de parenthèses redondantes
• En tant que type-id il s'agit du type d'une fonction sans paramètres qui renvoie des informations. int .

Dans les contraintes sémantiques pour sizeof c'est-à-dire C++14 [expr.sizeof]/1, il explique que la forme sizeof( type-id ) ne peut pas être appliquée à un type de fonction.

Cependant, je ne suis pas sûr que la violation de cette contrainte sémantique implique que sizeof( int() ) est correct et utilise le sizeof Expression unaire ou s'il existe une autre règle qui permet de distinguer les deux cas à un stade antérieur de la correspondance grammaticale.

NB. Pour l'autre question sizeof(void()) aucune des deux interprétations n'est valide, on peut donc affirmer que le compilateur a raison de rejeter l'expression avec un message d'erreur indiquant qu'elle correspond à l'option type-id forme. Cependant, gcc rejette sizeof( int() ) avec un message sur type-id .

Pour être clair, ma question est : "Est-ce que sizeof( int() ) une expression légale ?", en particulier sur le détail de la façon dont la correspondance grammaticale fonctionne lorsque les deux cas cités ci-dessus correspondent.

Answer 1

Non, sizeof( int() ) est mal formé car int() est considéré comme un type-id . Plus précisément, c'est un type de fonction, et sizeof ne peut pas être appliquée à un type de fonction.

[dcl.ambig.res]/2 :

Une ambiguïté peut naître de la similitude entre un style de fonction et un type-id . La résolution est que toute construction qui pourrait éventuellement être un type-id dans son contexte syntaxique est considéré comme un type-id .

avec cet exemple précis donné :

void foo(signed char a) {
    sizeof(int());                // type-id (ill-formed)
    sizeof(int(a));               // expression
    sizeof(int(unsigned(a)));     // type-id (ill-formed)