Dati di lancio perdendo C

Question

Cerco di capire quando il casting provoca la perdita di dati e come funziona. Quindi per i seguenti esempi provo a capire se c'è perdita di dati e se sì, perché: (i - int(4),f - float(4),d-double(8))

i == (int)(float) i; // sizeof(int)==sizeof(float) <- no loss
i == (int)(double) i; // sizeof(int)!=sizeof(double) <- possible loss
f == (float)(double) f;// sizeof(double)!=sizeof(float) <- possible loss
d == (float) d;// sizeof(double)!=sizeof(float) <- possible loss

È sufficiente basare la risposta solo sulle dimensioni del tipo? (+ Round)

Answer 1

Supponendo che i 32 bit INT e le normali byte IEEE-754 galleggiano/doppi sarebbe:

i == (int)(float) i;     // possible loss (32 -> 23 -> 32 bits)
i == (int)(double) i;    // no loss (32 -> 52 -> 32 bits)
f == (float)(double) f;  // no loss (23 -> 52 -> 23 bits)
d == (float) d;          // possible loss (52 -> 23 -> 52 bits)

Si noti che INT ha 32 bit di precisione, il galleggiante ha 23 bit, il doppio ha 52.

Answer 2

La memoria allocata per archiviare la variabile di un tipo non è l'unico fatto per considerare la perdita di dati. In generale, il modo per Roundaff e come la CPU elabora i dati numerici in caso di overflow sarebbero altri aspetti che potresti voler esaminare.

Answer 3

Perché il sizeof Rapporti della stessa dimensione in memoria non significa che vi sia perdita di dati.

Considera 0,5.

Può archiviarlo in un galleggiante ma non può archiviarlo in un numero intero.

Pertanto la perdita di dati.

Cioè voglio 0,5 di quella torta. Non può rappresentarlo come intero. O non ottenere nulla o molte torte. Yum

Answer 4

Perché intero? Perché potrebbe essere necessario solo numeri interi, ad esempio un ID_num

Perché galleggiare? Perché potrebbe essere necessario lavorare sull'esempio dei numeri reali % calculations

Perché doppio? Quando hai numeri reali che non possono adattarsi alla dimensione del galleggiante