Why does my function print '0'? - c++

Question

Here is my code, I don't exactly know why does this happen:
#include <stdio.h>
void foo(float *);
int main()
{
int i = 10, *p = &i;
foo(&i);
}
void foo(float *p)
{
printf("%f\n", *p);
}
OUTPUT :
0

Answer 1

As it has been already said you are passing an address of integer variable as an address of single precision floating point number.
Ideally, such implicit conversion should be disallowed, but depending on compiler and whether it is clean C or C++, it may just result in warning.
But why does it print exactly 0?
It is because of the way the single precision FPN is represented in memory:
(1 bit of sign)|(8 bits of biased exponent)|(23 bits of significand(mantissa))
10 in binary is
0|0000 0000|000 0000 0000 0000 0000 0000 1010
So, when interpreted on as floating point value:
(sign = 0)(biased exponent = 0)(significand = 10)
biased exponent is normal exponent plus 127 - http://en.wikipedia.org/wiki/Exponent_bias
To calculate the value we will use following formula:
floatValue = ((sign) ? (-1) : (1)) * pow(2, normalExponent) * significand
That will yield:
floatValue = 1 * pow (2, 0 - 127) * 10 = 10 * 2 in pow -127.
It is a very small number, that when represented using %f specifier turns into "0" string.
SOLUTION:
To solve this problem just use temporary variable and explicit cast before calling the foo:
int main()
{
int i = 10;
float temp = (float)i;
foo(&temp);
}
void foo(float *p)
{
printf("%f\n", *p);
}
P.S. To avoid such problems in future always set your compiler to maximum realistic level of warnings and always deal with each of them before running the app.

Answer 2

Because you are declaring your integer object and pointer object to int and int * instead of float and float *.
You cannot pass an object of type int * to a function that expects an argument of type float * without an explicit conversion.
Change:
int i = 10, *p = &i;
to
float i = 10, *p = &i;
Note that your p pointer in main is not used and its declaration can be removed.

Answer 3

You are essentially casting a pointer to an int to a pointer to a float. This is legal but BAD- the printf is trying to understand the memory reserved for the int as a float (which would be represented differently in memory) and the results are undefined.

Answer 4

You try to read area allocated to a variable of type int and try to read is as float.
Floats are written as mantissa and an exponent. Depending on representation in memory, it's likely you're loading up the exponent with your "10" while mantissa remains zero. As result, 0^10 (or however it's interpreted) is 0.

Answer 5

It is due to, you are passing an Integer to a function and you are catching with float data type.
When you compile it- you will get warning if you enable the warning flags-
root#sathish1:~/My Docs/Programs# cc float1.c
float1.c: In function ‘main’:
float1.c:11:5: warning: passing argument 1 of ‘foo’ from incompatible pointer type [enabled by default]
float1.c:3:6: note: expected ‘float *’ but argument is of type ‘int *’
It clearly tells you what you are doing.
Your function is excepting float *, but you are passing int *. So when printing, it will search the respective memory area and try to print it. But float variables are stored in IEEE 754 standard, but the function receives an address of integer, so it will try to print the data in that memory location(int is not stored in IEEE 754 std). So result is Undefined.

Answer 6

You are calling function expecting float* with a pointer to int. In C++ it is an error and your code does not compile. In C you will most likely get a warning and undefined behaviour anyway.