La conversion de type implicite modifie-t-elle la taille de la variable

par exemple,

#include  int main (void) { int x = 5; double y = 6; int z = x+y; printf("size of z = %d bytes",sizeof(z)); return 0; } 

La sortie est de 4 octets, pourquoi ne pas convertir en double et prend 8 octets de mémoire en double.

Lisez les commentaires décrivant votre comportement du code:

 #include  int main (void) { int x = 5; double y = 6; int z = x+y; // 5 (int, 4 bytes) + 6 (double, 8 bytes) // converting `int` to `double` when adding them () // 5.0 (double, 8 bytes) + 6.0 (double, 8 bytes) // 11.0 (double, 8 bytes) // But! `z` is of type `int`, so it will not convert to `double` // Then 11.0 converts to 11 because `z`... is of type `int`! /// read "Double-precision floating-point format" and you'll see why. // So, z = 11 (`z` is of type `int`, so it's size is *4* bytes ) // Here is your 4 bytes instead of 8! ;) printf("size of z = %d bytes",sizeof(z)); return 0; 

}

Non, sizeof z sera toujours sizeof(int)

Quand tu fais:

 int z = x+y; 

La valeur de x sera convertie en double puisque y est double, mais cela ne changera pas x . Et le résultat de x+y (type double ) sera converti en int et atsortingbué à z .

Vous avez défini z comme entier. Tout en faisant “x + y”, l’ajout a lieu à la taille double, mais lors de l’atsortingbution, il effectue une conversion implicite et tronque le résultat pour l’adapter à la taille de z.

Depuis que tu as déclaré z étant int, ce sera int . Et chaque conversion possible sera de tout type à int:

  int z = whatever (legal) formula you put here; sizeof(z); /* <- 4 */ 

au contraire, la valeur temporelle de x + y est double et est finalement convertie en int

  int x = 5; double y = 6; int z = x+y; /* x + y = 11.0 since y = 6.0; which is converted to 11*/ 

Votre sortie est 4 parce que vous déclarez int z . z sera toujours de type int .

Même si l’expression x+y est de type double parce que y est un double , cette expression sera implicitement convertie en int car vous essayez d’affecter int à et int .

Vérifiez ce code:

 #include  int main() { int x = 4; double y = 5; int z = x+y; printf( "%d %d \n", sizeof(z), sizeof( x + y ) ); return 0; } 

La sortie sera 4 8 car z est de type int et l’expression x+y de type double . Exemple