CODEWITHSUNDEEP
c
4386427
4386427

Reputation: 44368

Specify float when initializing double. gcc and clang differs

I tried running this simple code on ideone.com

#include<stdio.h>
int main()
{
    double a = 0.7f;  // Notice: f for float
    double b = 0.7;

    if (a == b) 
        printf("Identical\n"); 
    else 
        printf("Differ\n");

    return 0;
}

With gcc-5.1 the output is Identical

With clang 3.7 the output is Differ

So it seems gcc ignores the f in 0.7f and treats it as a double while clang treats it as a float.

Is this a bug in one of the compilers or is this implementation dependent per standard?

Note: This is not about floating point numbers being inaccurate. The point is that gcc and clang treats this code differently.

Upvotes: 4

Views: 880

Answers (2)

Tom Tanner
Tom Tanner

Reputation: 9354

The compiler is required to convert the literal into an internal representation which is at least as accurate as the literal. So gcc is permitted to store floating point literals internally as doubles. Then when it stores the literal value in 'a' it will be able to store the double. And clang is permitted to store floats as floats and doubles as doubles.

So it's implementation specific, rather than a bug.

Addendum: For what it is worth, something similar can happen with ints as well

int64_t val1 = 5000000000;
int64_t val2 = 5000000000LL;
if (val1 != val2) { printf("Different\n"); } else { printf("Same\n"); }

can print either Different or Same depending on how your compiler treats integer literals (though this is more particularly an issue with 32 bit compilers)

Upvotes: 2

Art
Art

Reputation: 20402

The C standard allows floating point operations use higher precision than what is implied by the code during compilation and execution. I'm not sure if this is the exact clause in the standard but the closest I can find is §6.5 in C11:

  1. A floating expression may be contracted, that is, evaluated as though it were a single operation, thereby omitting rounding errors implied by the source code and the expression evaluation method

Not sure if this is it, or there's a better part of the standard that specifies this. There was a huge debate about this a decade ago or two (the problem used to be much worse on i386 because of the internally 40/80 bit floating point numbers in the 8087).

Upvotes: 3

Related Questions