Pourquoi sizeof(x++) n'incrémente pas x ?

Question

Voici le code compilé en dev c++ Windows :

#include <stdio.h>

int main() {
    int x = 5;
    printf("%d and ", sizeof(x++)); // note 1
    printf("%d\n", x); // note 2
    return 0;
}

J'attends x à 6 après l'exécution de note 1 . Cependant, le résultat est :

4 and 5

Quelqu'un peut-il expliquer pourquoi x ne s'incrémente pas après que note 1 ?

Answer 1

A partir de la Norme C99 (l'accent est mis par moi)

6.5.3.4/2

L'opérateur sizeof donne la taille (en octets) de son opérande, qui peut être une expression ou le nom entre parenthèses d'un type. La taille est déterminée à partir du type de l'opérande. Le résultat est un entier. Si le type de l'opérande est un type de tableau de longueur variable, l'opérande est évalué, sinon, l'opérande n'est pas évalué et le résultat est une constante entière.

Answer 2

sizeof est un opérateur de compilation Ainsi, au moment de la compilation sizeof et son opérande sont remplacés par la valeur du résultat. L'opérateur L'opérande est non évaluée (sauf s'il s'agit d'un tableau de longueur variable). type du résultat importe.

short func(short x) {  // this function never gets called !!
   printf("%d", x);    // this print never happens
   return x;
}

int main() {
   printf("%d", sizeof(func(3))); // all that matters to sizeof is the 
                                  // return type of the function.
   return 0;
}

Sortie :

2

comme short occupe 2 octets sur ma machine.

Changer le type de retour de la fonction en double :

double func(short x) {
// rest all same

donnera 8 en sortie.

Answer 3

sizeof(foo) s'efforce de découvrir la taille d'une expression au moment de la compilation :

6.5.3.4 :

L'opérateur sizeof donne la taille (en octets) de son ou le nom parenthésé d'un type. La taille est déterminée à partir du type de l'opérande. Le résultat est un entier. Si le type de l'opérande est un tableau de longueur variable l'opérande est évalué ; sinon, l'opérande n'est pas évalué et le résultat est une constante entière. constante entière.

En bref : des tableaux de longueur variable, exécutés au moment de l'exécution. (Remarque : Tableaux de longueur variable sont une caractéristique spécifique -- et non des tableaux alloués avec des malloc(3) .) Dans le cas contraire, seuls les type de l'expression est calculée, et ce au moment de la compilation.

Answer 4

sizeof est un opérateur intégré à la compilation et est pas une fonction. Cela devient très clair dans les cas où vous pouvez l'utiliser sans les parenthèses :

(sizeof x)  //this also works

Answer 5

Note

Cette réponse a été fusionnée à partir d'un doublon, ce qui explique la date tardive.

Original

À l'exception de tableaux de longueur variable taille de n'évalue pas ses arguments. C'est ce que montre la section du projet de norme C99 6.5.3.4 La taille de l'opérateur paragraphe 2 qui dit :

L'opérateur sizeof donne la taille (en octets) de son o ou le nom parenthésé d'un type. La taille est déterminée à partir du type de l'opérande. Le résultat est un entier. Si le type de l'opérande est un type de tableau à longueur variable l'opérande est évalué ; sinon, l'opérande n'est pas évalué et le résultat est une constante entière. constante entière.

Un commentaire( maintenant supprimée ) a demandé si une telle chose pouvait être évaluée au moment de l'exécution :

sizeof( char[x++]  ) ;

et c'est effectivement le cas, quelque chose comme ceci fonctionnerait également ( Voir les deux en direct ):

sizeof( char[func()]  ) ;

puisqu'il s'agit dans les deux cas de tableaux de longueur variable. Cependant, je ne vois pas d'utilité pratique à l'un ou à l'autre.

Remarque : les tableaux de longueur variable sont traités dans la section projet de norme C99 section 6.7.5.2 Déclarateurs de tableaux paragraphe 4 :

[...] Si la taille est une expression constante entière et que le type d'élément a une taille constante connue, le type de tableau n'est pas un type de tableau à longueur variable ; sinon, le type de tableau est un type de tableau à longueur variable.

Mise à jour

En C11, la réponse change pour le cas VLA, dans certains cas, il n'est pas précisé si l'expression de la taille est évaluée ou non. De la section 6.7.6.2 Déclarateurs de tableaux qui dit :

[...] Lorsqu'une expression de taille fait partie de l'opérande d'une expression de taille de et que la modification de la valeur de l'expression de taille ne serait pas pas le résultat de l'opérateur, il n'est pas précisé si l'expression de l'expression de taille est évaluée ou non.

Par exemple, dans un cas comme celui-ci ( voir en direct ):

sizeof( int (*)[x++] )