Copying data from float to an int, without the data being casted

Question

In the following code I try to copy data from a float f to an int i, bit for bit, without any conversion of the data. I cast the address of f to (int*), and dereference this address when I assign it to i. The thinking is that if the program sees &f as an int pointer, it won't do a type conversion when (int*) f is dereferenced and assigned to i. But this isn't working and I do not understand why.

void main(){
  float f=3.0;
  int i;

  /* Check to make sure int and float have the same size on my machine */
  printf("sizeof(float)=%d\n",sizeof(float)); /* prints "sizeof(float)=4" */
  printf("sizeof(int)=%d\n",sizeof(int)); /* prints "sizeof(int)=4" */

  /* Verify that &f and (int*) &f have the same value */
  printf("&f = %p\n",&f); /* prints &f = 0x7ffc0670dff8 */
  printf("(int*) &f = %p\n",(int*) &f); /* prints (int*) &f = 0x7ffc0670dff8 */

  i=*((int*) &f);
  printf("%f\n", i); /* prints 0.000000 (I would have expected 3.000000) */
  return;
}

You're invoking undefined behaviour by passing an `int` to `printf` when you've specified `%f`. — Oliver Charlesworth, Nov 21 '15 at 20:06
..yes, a `float` would be promoted to `double` but an `int` will not be. — Weather Vane, Nov 21 '15 at 20:10
@Olaf Wouldn't a converting a float to a double be considered a widening conversion, and therefore OK? (This is a question, I'm not challenging your answer). — jensa, Nov 21 '15 at 20:15
@jensa: Sorry, yes, you are right. Point taken. (I confused this with `scanf`s passing a pointer). I don't use `printf/scanf` in C normally. — too honest for this site, Nov 21 '15 at 20:19
In addition to what @OliverCharlesworth said, you also invoke UB supplying an `int *` to `%p` which requires a `void *` argument. — Jens, Nov 21 '15 at 20:27

score 1 · Answer 1 · answered Nov 21 '15 at 20:27

By assigning via typecasting you are copying the raw 4 bytes of data from one variable to another. The problem is that a 3 in a 32-bit floating point variable isn't stored like a 3 in an integer variable.

For example, a 3 in 64-bit float format on a Mac is stored as 0x4e808000. Assigning that into an integer will produce 1077936128.

See https://en.wikipedia.org/wiki/IEEE_floating_point or http://www.madirish.net/240 or https://users.cs.duke.edu/~raw/cps104/TWFNotes/floating.html

score 1 · Answer 2 · edited May 23 '17 at 12:03

Creating two pointers of unrelated types to the same object violates the strict aliasing rule. You want to avoid this, as in complicated code it can cause the compiler to produce binaries that don't do what you want. It's also undefined behaviour.

The correct way to change the type of a bit pattern in C between int and float is to avoid pointers completely, and use a union:

union int_float { int i; float f; };

int ival = (union int_float){ .f = 4.5 }.i;
float fval = (union int_float){ .i = 45 }.f;

Results may vary slightly. Be sure to check that the sizes of your floating type and your integer type are identical, or data will be lost/garbage data generated.

Note that it is possible to produce values in this way that are not valid elements of the destination type (this is more or less what you're seeing above when non-zero integer values get interpreted as floating-point zeroes despite not having all-zero bit patterns), which could lead to undefined or unexpected behaviour further down the line. Be sure to verify the output.

gaetanoM · Answer 3 · 2015-11-21T20:46:09.490

0

after the conversion you obtain an integer stored in the variable i. So if you wannt to print such a value you have to use:

printf("%d\n", i); /* prints 1077936128 */

Now the printf will interprets correctly the memory bits and print the correct value. This is not a cast but a bit copy like you said. Remember that ((int)&f) dereference that pointer into an int value. It won't do what you believe on machines where int and float have different sizes.

A different way to copy, if the sizes of int and float are identical, is:

memcpy(&i, &f, sizeof f);

After copying the four bytes contained in the memory area if we try to print the content as a sequence of four decimal values we can appreciate the redistribution just happened:

for floating:

3 160 0 3

for integer

0 204 204 0

This means that the four bytes are managed differently from the computer according to the type of rapresentation: int or float.

edited Nov 21 '15 at 20:46

answered Nov 21 '15 at 20:18

gaetanoM

41,594
6
42
61

If it's a bit copy, shouldn't the four decimal values be the same for both the float and the integer? – john smith Nov 21 '15 at 20:59
@johnsmith the four bytes cannot be the same because it's up to the computer rappresentation of int and float: this is the difference betweeen a int and a float on my computer. When you assign a value to a float and then copy it to an int area the computer will understand how correctly manage this – gaetanoM Nov 21 '15 at 21:05
1

There are many different ways a computer can store numbers - one's complement, two's complement, IEEE 754, BCD (binary coded decimal), SANE (old Mac 80-96 bit format), little endian, big endian, etc. Copying the raw bytes between the various formats does not work. The same number will have different bytes in each format. See https://en.wikipedia.org/wiki/Signed_number_representations – EricS Nov 21 '15 at 22:35
Yes you are right but my simple intention is to show the difference between a bit copy from a cast. I assume this is not enough clear to the person who posted the question. – gaetanoM Nov 21 '15 at 23:03

Copying data from float to an int, without the data being casted

3 Answers3