CODEWITHSUNDEEP
c
Ajay Yadav
Ajay Yadav

Reputation: 1645

Why the same value of float and a string that is converted into float using function atof are not equal?

I have written a program in C and when I compare the same values of a float and a string that is converted into float using function atof results in NOT EQUAL .

    #include<stdio.h>

    main(){

            char str[10] = "54.23" ;
            float val = 54.23 ;


            if( atof(str) == val )
                 printf("\nconverted correctly");
            else
                 printf("\nThen What is the use of atof\n ");


       }

This Program is showing output : "Then What is the use of atof" Please tell me why this anonymous behavior is shown by this program ?

Upvotes: 2

Views: 1093

Answers (4)

rajesh6115
rajesh6115

Reputation: 735

double atof(char *str);\\it return double not a float

This comparison is between a float and a double.As you compare between two different types you may get some unexpected output.because every data type having different memory representation as well as different access mechanism.

float represent in memory in different form as compare to double .

you can learn more about this in wikipedia also

http://en.wikipedia.org/wiki/Floating_point#Internal_representation

Again you should include the header file 

#include <stdlib.h> \\prototype of atof() present in this header.

if you not provide the proper prototype before use of the function then

return type of function by default int .So I think the return result is definitely different as you expected.

Upvotes: 1

Paul R
Paul R

Reputation: 213029

Never test floats/doubles for equality with ==

Here's a version of your code which actually displays the values in question:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char str[10] = "54.23";
    float val = 54.23;

    printf("atof(str) = %.15f\n", atof(str));
    printf("      val = %.15f\n", val);

    return 0;
}

When you run it you see this:

$ gcc -Wall atof.c
$ ./a.out 
atof(str) = 54.229999999999997
      val = 54.229999542236328
$

The values are close, within the expected accuracy of a single precision float, but they are not identical. Also, as others have noted, atof returns a double, so you are comparing the value of a float promoted to a double with a full precision double as returned by atof.

As always with this type of question, read this before proceding any further with floating point arithmetic in your code. The "take home message" is that you should never compare floats or doubles with == - always compare the absolute difference with an appropriate tolerance value.

Upvotes: 5

geometrian
geometrian

Reputation: 15387

You almost never want to check equality with floating point numbers, because teensy differences will be read as unequal. There are other problems, too. For example, even if you use double precision, for instance, the decimal number "0.1" is represented as "0.10000000000000001".

In this case, your "val" variable is a double precision literal, which is cast to a float. The result probably won't be accurate perfectly. Secondly, your string literal needs to convert from base ten to a base 2 double. So, to compare the atof value to your literal, atof converts a base ten string to a base two double, while "val" was converted from a base ten literal to a base two double to a base two float, and then upcast back to a base two double to do the comparison.

Point of fact, I'm not going to pin down exactly where that lost precision went. Do as Paul's code might suggest and compare the values to within a tolerance.

Upvotes: 0

user529758
user529758

Reputation:

Because val is an int; when you assign it 54.23 it'll be truncated to 54. And 54 != 54.23.

Even if it was a float, you couldn't expect them to be equal. Here's why.

Upvotes: 2

Related Questions