Double to int implicit conversion in mingw32

Question

I can't explain the behaviour of the following program (compiled with gcc on mingw 32 bits). I'm aware of the possible precision loss when implicitly converting from double to int, but I would expect the two cases to give the same output since it is doing the exact same operations. Why are the two outputs different?

#include <stdio.h>
#include <math.h>

int main()
{
    int table[3] = {2, 3, 4};
    int i, N;

    N = 0;
    N += table[0] * pow(100, 0);
    N += table[1] * pow(100, 1);
    N += table[2] * pow(100, 2);
    printf("%d\n", N);

    N = 0;
    for(i = 0; i < 3; i++)
        N += table[i] * pow(100, i);
    printf("%d\n", N);

    return 0;
}

//output: 
40302
40300

Answer 1

With pow(100, 0) pow(100, 1) and pow(100, 2) the compiler replaces the function calls with constants ( 1, 100, 10000 ), but with pow(100, i) it has to actually call the function at runtime (because of the variable i being passed as argument), resulting with two results of pow in the form 0.99999999 and 99.999999 instead of 1 and 100 (or any 2 of the 3). When truncating to int after the multiply you "lose" two units.

This is another example of why converting to int from double is just pure evil : very hard to find subtle bugs in your program (not compiler bugs).

Btw, I am surprised that the compiler with O2 didn't unroll the loop, propagate the constants and reach the same optimization (replacing the function call with constant results).

Btw2 Scratch that, I am surprised that the compiler didn't just replace all you code with only two calls to printf .