Question

I am confused as to this part of exemplary code:

float f = 3.01;
int i;

• Case 1: i = f * 100; // i == 300
• Case 2: i = f *= 100; // i == 301

I’ve no idea why in first case the decimal part gets “lost”.
I’ve also tried:

(double) f * 100
f * 100.0

Then I tried volatile and flags to gcc that turn off all optimization.
The result is still the same.

Can somebody explain to me why does the first case behave so? Thank you.

Answer 1

The issue is in type conversion:

int i = f * 100 ;

is equivalent to

double tmp = f* 100.0;
int i = tmp;

And the difference with second case is that tmp is double! And yes, there is a case, where double is “less precise”

To illustrate this, I wrote the follwing program:

int main()
{
    float f = 3.01;
    float mf = f * 100;
    double md = f * 100;

    int if_ = mf;
    int id = md;

    std::cout << f << ' ' << mf << ' ' << md << ' ' << ' ' << (mf - md) << ' ' << if_ << ' ' << id << '\n';
}

Edit:

On my system I get same result for my gcc 4.6.1 and cl 16.00 (MS VS 10):

3.01 301 301  9.53674e-007 301 300

Edit2

Found, that enabling optimization -O2 eliminates issue. This explains difference with IDEONE.

Here is another code:

int main()
{
    float f = 3.01;
    float mf = f * 100;
    return mf + (f*100);

    //std::cout << f << ' ' << mf << ' ' << md << ' ' << ' ' << (mf - md) << ' ' << if_ << ' ' << id << '\n';
}

And its assembly with -O0

    movl    $0x4040a3d7, %eax
    movl    %eax, 28(%esp)


    flds    28(%esp)
    flds    LC1
    fmulp   %st, %st(1)
    fstps   24(%esp)
    flds    28(%esp)
    flds    LC1
    fmulp   %st, %st(1)
    fadds   24(%esp)
    fnstcw  14(%esp)
    movw    14(%esp), %ax
    movb    $12, %ah
    movw    %ax, 12(%esp)
    fldcw   12(%esp)
    fistpl  8(%esp)
    fldcw   14(%esp)
    movl    8(%esp), %eax

We can see only one explicit conversion to single precision instruction (fspts). This conforms my guess, that temporary evaluates from double, not float.

And with -O2 assembly is pretty simple:

    movl    $602, %eax

And at last

If we disable optimization of evaluting, IDEONE compiler reproduce behavior too: