Styjun

I have recently taken a lecture of System Programming, and my professor told me that f == (float)(double) f is which wrong that I cannot get.

I know that double type loses its data when converted to float, but I believe the loss happens only if the stored number in double type cannot be expressed in float type.

Shouldn't it be true as same as x == (int)(double)x; is true?

the picture is the way I'm understanding it

I'm so sorry that I didn't make my question clearly.

the question is not about declaration, but about double type conversion.
I hope you don't lose your precious time because of my fault.

Assuming IEC 60559, the result of f == (float)(double) f depends on the type of f.

Further assuming f is a float, then there's nothing "wrong" about the expression - it will evaluate to true (unless f held NaN, in which case the expression will evaluate to false).

On the other hand, x == (int)(double)x (assuming x is a int) is (potentially) problematic, since a double precision IEC 60559 floating point value only has 53 bits for the significand¹, which cannot represent all possible values of an int if it uses more than 53 bits for its value on your platform (admittedly rare). So it will evaluate to true on platforms where ints are 32-bit (using 31 bits for the value), and might evaluate to false on platforms where ints are 64-bit (using 63 bits for the value) (depending on the value).

Relevant quotes from the C standard (6.3.1.4 and 6.3.1.5) :

When a value of integer type is converted to a real floating type, if the value being converted can be represented exactly in the new type, it is unchanged.

When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined.

When a value of real floating type is converted to a real floating type, if the value being converted can be represented exactly in the new type, it is unchanged.

¹ a double precision IEC 60559 floating point value consists of 1 bit for the sign, 11 bits for the exponent, and 53 bits for the significand (of which 1 is implied and not stored) - totaling 64 (stored) bits.

Taking the question as posed in the title literally,

Why is the statement “f == (float)(double)f;” wrong?

the statement is "wrong" not in any way related to the representation of floating point values but because it is trivially optimized away by any compiler and thus you might as well have saved the electrons used to store it. It is exactly equivalent to the statement

1;

or, if you like, to the statement (from the original question)

x == (int)(double)x;

(which has exactly the same effect as that in the title, regardless of the available precision of the types int, float, and double, i.e. none whatsoever).

Programming being somewhat concerned with precision you should perhaps take note of the difference between a statement and an expression. An expression has a value which might be true or false or something else, but when you add a semicolon (as you did in the question) it becomes a statement (as you called it in the question) and in the absence of side effects the compiler is free to throw it away.

NaNs are retained through float => double => float, but they not equal themselves.

#include <math.h>
#include <stdio.h>

int main(void) 
 float f = HUGE_VALF;
 printf("%dn", f == (float)(double) f);
 f = NAN;
 printf("%dn", f == (float)(double) f);
 printf("%dn", f == f);

Prints

1
0 
0