Dereferencia al lanzar el puntero del vacío para flotar * / int *

UNA

int i = 10; void *p = &i; printf("%f\n", *(float*)p); 

segundo

 float i=10.00; void *p = &i; // no change printf("%d\n", *(int*)p); 

¿Por qué A imprime 0.0, no 10.0? Si cambiamos de A a B, entonces su salida es basura.

Para ser más precisos sobre lo que dicen los demás, aquí hay una prueba:

 #include  int main() { int a = 10; float b = 10; char * p; p = &a; printf("int repr: %02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]); p = &b; printf("float repr: %02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]); return 0; } 

La salida es

 int repr: 0a 00 00 00 float repr: 00 00 20 41 

Esta espectáculos:

a) Es una pequeña máquina endiana, ya que el byte más bajo del int viene primero en la memoria b) el int tiene la representación con los bytes 0a 00 00 00 , por lo que el valor es 0000000a , la representación hexadecimal de, bueno, 10. c) el flotador es de hecho 41200000 . Según IEEE 754 , esto significa que tiene un bit de signo, 8 bits de exponente y 23 bits de mantisa. El signo es 0 (+), el exponente es 0x82 , lo que significa +3, y la mantisa es 010000... , lo que significa 1.01 en binario o 1.25 en decimal.

Juntos, estos datos forman el valor 2 * 2 * 2 * 1.25 = 8 * 1.25 = 10.

Porque realmente no estás haciendo un reparto en el primer caso, estás lanzando tipos de punteros.

Si quieres 10.0, así es como lo harías:

 int i = 10; printf("%f\n", (float)i); 

Esto es lo que estás haciendo ahora:

 int i = 10; // Create int i and initialize to 10. void *p = &i; // Get an untyped pointer and set it to the address of i printf("%f\n", *(float*)p); // Treat the pointer p as a float pointer and dereference it, printing it as a float. 

Dado que int y float tienen representaciones diferentes, no hay razón para creer que esto funcione.

Básicamente, lo que estás haciendo es lanzar un void * a un float * / int * , es decir, estás lanzando tipos de punteros y luego eliminándolos de la referencia. Dado que la operación de desreferenciación se comporta de manera diferente según el tipo, no hay razón para creer que esto debería funcionar. Puedes probar este código y ver la diferencia:

 int i = 10; void *p = &i; printf("%d\n", *(int*)(p));