Thread: K&R question

This is probably the fifth time I am reading this book and everytime around I notice little details that I had not noticed previously. This time, right on the beginning of the book, something caught my attention. On page 12, there's a program that prints the Fahrenheit-Celsius table and the authors use floats to store both temperatures. There is also a while loop where they compare the current value of the fahr variable against the value of the upper limit of the table, which is an int. So we have this:

Code:

float fahr;
int upper = 300;

while (fahr <= upper)
   ...

I understand that in an operation, operands have to have the same types, so in this case, upper, which is an int, will be converted to float before the comparison is done, right? Now isn't it dangerous to compare floating-point values? Isn't it almost the same as doing something such as this?

Code:

float i;
for (i = 0.0; i <= 10.0; i += 0.1)
   ...

Thanks.

It is indeed dangerous to compare floating points values for equality

Code:

if( i == 10.0)

But that is not what your loop is doing. Comparing for a range of values is ok.

>>Also, there is no difference in comparing with a range or comparing to a single specific value.

There most certainly is a difference -- program-wise no, but it can (and often does) cause runtime problem due to the inaccuracy of floating point. The value 10.0 may or may not really be represented internally as 10.0 -- for instance it could be 10.00000123. So any attempt to compare a float (or double) with that will most certainly fail.

I can't imagine comparing a float to an int would be a big problem. If the floats are stored in your machine as per the IEEE standard for 32-bit or 64-bit floats, they are pretty damn accurate. As long as you aren't comparing two floats that don't differ by some ridiculously small percentage and that have over 20 significant digits, you should be OK.

The coercion in C really doesn't matter between ints and floats, regardless. People were coding in C for many years where there was no type checking at all. It wasn't until an ANSI C standard that came out inthe late eighties or early nineties that type checking was made an official part of the language, AFAIK. I'm sure comparisons like the one you noticed aren't considered as bothersome to programmers because they are intuitive and have intuitive results.

>>I can't imagine comparing a float to an int would be a big problem

It will do an integer comparison -- the float is truncated to an integer, dropping any and all fractional parts. So, if (an int) x == 1 and (a float) y == 1.2, an attempt to find out if y > x will fail

That doesn't make sense. Shouldn't coercion always go towards the more complex of the two? I know that it goes int -> float in java...

Chalk that up to counterintuitive language design.

Isn't that completely backwards? Isn't the int promoted to a float?

Microsoft 2003 says that's backwards. That may not follow the standard but I don't see any reason that it wouldn't