Thread: In C# and C++, are conversion warnings important, and should attention be paid to them, or should they be ignored?

warning C4305: 'argument' : truncation from 'double' to 'float'

Warnings like this

and conversion from int to float, int to double, float to double, etc...

Assuming im not aiming for:
accuracy,
optimizing performance,
nor memory usage,
are there any possible OTHER side effects from just ignoring these stuff?

btw, i have got over 550 conversion warnings..!!

I also have a question on how to truncate:
the integer (rounded off a float).

i've done this,

Code:

float myNum = 9.12345f;
int theIntTruncation = myNum;
float remainding = myNum - theIntTruncation;

But there are the conversion warnings coming out (see OP)

i've tried using cmath::truc(click), but then i think its not backward compatible with some versions..

is there any way to solve this issue without warnings? or do i just leave my code as it is and ignore those annoying warnings?

Thanks for reading through, please reply if you know of an answer. Thanks!!

i'd do something like :

Code:

float myNum = 9.12345f;
int theIntTruncation = (int)myNum;
float remainding = myNum - theIntTruncation;

that'll work in c#, don't know for sure about c++

The warnings are a code smell.

Code smell - Wikipedia, the free encyclopedia
"In computer programming, code smell is any symptom in the source code of a program that possibly indicates a deeper problem. Code smells are usually not bugs—they are not technically incorrect and do not currently prevent the program from functioning. Instead, they indicate weaknesses in design that may be slowing down development or increasing the risk of bugs or failures in the future."

Originally Posted by marnixR

Code:

float myNum = 9.12345f;
int theIntTruncation = (int)myNum;
float remainding = myNum - theIntTruncation;

Although that code will compile without warnings/errors, the results will not always be correct.

Try stepping through this code and you will see the problems:

Code:

float myNum = float.MaxValue;
int theIntTruncation = (int)myNum;
float remainding = myNum - theIntTruncation;

int ranges from -2,147,483,648 to 2,147,483,647.
float ranges from -3.4 × 10³⁸ to +3.4 × 10³⁸


Once the float variable goes above 2,147,483,647 the code will start producing incorrect results.

Originally Posted by RamenNoodles

Assuming im not aiming for:
accuracy,

That would be your primary mistake.

Wow i didn't think until the scope.

That's nice info to know. So is (int) type casting the proper way to truncate?

Originally Posted by RamenNoodles

Wow i didn't think until the scope.

That's nice info to know. So is (int) type casting the proper way to truncate?

I would use something like

Code:

float myNum = 123.456F;
float theIntTruncation = (float)Math.Floor(myNum);
float remainding = myNum - theIntTruncation;

but there are floating point errors expected with these kinds of operations.
For example, the above code returns a value of 0.456001282.

Even this code

Code:

float result = 123.456F - 123;

returns a result of 0.456001282

Some people take the route of converting the float to a string; extracting the part after the decimal separator and then prefixing it with a "0.".
It works, even if it is a bit of a hack.

If you fancy a detailed read about floating points: What Every Computer Scientist Should Know About Floating-Point Arithmetic

But I guess I am drifting off-topic.

In modern computers, it's a pretty good idea to always use doubles unless you really need the extra memory. As far as I know, there's no significant speed difference between the two anymore. Floating point errors are proportional to the low bits of the mantissa, which is much smaller with doubles.

But yeah, any time you're working with floating point numbers (floats or doubles) you just have to expect some floating point errors to creep in. The best you can do is pay attention to things like warnings and be careful not to do things that would magnify those errors. (One reason you shouldn't compare two floats with ==, which I don't think will even give you a warning though it probably should.)

Originally Posted by RedPanda

Although that code will compile without warnings/errors, the results will not always be correct.

it all depends whether the rounding off error is something you can live with for the purpose you have in mind
for many house-and-garden web page applications it's usually not an issue
if you need engineering/scientific accuracy to multiple decimal places or work with really large numbers then you have to take more care

Originally Posted by marnixR

Originally Posted by RedPanda

Although that code will compile without warnings/errors, the results will not always be correct.

it all depends whether the rounding off error is something you can live with for the purpose you have in mind
for many house-and-garden web page applications it's usually not an issue

Yes, which is why it is a Code Smell rather than a bug.

Originally Posted by marnixR

if you need engineering/scientific accuracy to multiple decimal places or work with really large numbers then you have to take more care

But it can be avoided completely by simply not casting it to an Int.
And avoiding Code Smells is a good habit to learn.

I understand the need for the occasional hack when time is short - but this is not one of those times.
It takes as long to do it correctly as it does to do it incorrectly.

In a enterprise type environment we treat all warnings as errors in our build (c++ compiler option /WX) and while you are at it think about maintaining ANSI c/c++ compliance (c++ compiler option /Za) which increases your chances of getting a gcc build working in the future without causing grievous harm to your own psyche.