Same program works on macos but fails on windows

Question

Ok, so I am working on an interface on qt, and I am using qtcreator as an IDE. The thing is that the algorithm works normally on mac, but on windows the same program gets an error.

the only difference is the compiler. The compiler I am using on windows is the visual c++, and on mac is clang (I think). Is it possible that the same algorithm works on mac but doesn't on windows? If so, what problem could it be?

EDIT: I see that I got downvoted. I don't know exactly why. I know already what the error means, vector subscription out of range. The thing is that I don't want to waste time trying to find where the error is because it actually works fine on mac. Also the pc is better than the mac one.

EDIT 2: Indeed it looks like the same code works differently on windows than on mac. Tomorrow I will test it on mac to try to understand this, but the code that changes is this one:

vector<double> create_timeVector(double simulationTime, double step) {
        vector<double> time;
        time.push_back(0);
        double i = 0;
        do {
            ++i;
            time.push_back(time[i-1] + step);
        } while (time[i] < simulationTime);
        return time;
    }

The size of the vector that is returned is one size bigger on windows than on the mac. The thing is that I didn't make any changes on the code.

Answer 1

The probable reason why it works differently is that you're using a floating point calculation to determine when the loop is to stop (or keep going, depending on how you look at it).

time.push_back(time[i-1] + step);
        } while (time[i] < simulationTime);

You have step as a double, simulationTime as a double, and a vector<double> called time being used. That is a recipe for loops running inconsistently across compilers, compiler optimizations, etc.

Floating point is not exact. The way to make the loops consistent is to not use any floating point calculations in the looping condition.

In other words, by hook or by crook, compute the number of calculations you need by using integer arithmetic. If you need to step 100 times, then it's 100, not a value computed from floating point arithmetic:

For example:

for (float i = 0.01F; i <= 1.0F; i+=0.01F) 
{ 
  // use i in some sort of calculation
}

The number of times that loop executes can be 99 times, or it can be 100 times. It depends on the compiler and any floating point optimizations that may apply. To fix this:

for (int i = 1; i <= 100; ++i ) 
{ 
  float dI = static_cast<float>(i) / 100.0F;
  // use dI instead of i some sort of calculation
}

As long as i isn't changed in the loop, the loop is guaranteed to always do 100 iterations, regardless of the hardware, compiler optimizations, etc.

See this: Any risk of using float variables as loop counters and their fractional increment/decrement for non "==" conditions?

Answer 2

vector subscript out of range means that you used [n] on a vector, and n was less than 0 or greater than or equal to the number of elements in the vector.

This causes undefined behaviour, so different compilers may react in different ways.

To get reliable behaviour in this case, one way is to use .at(n) instead of [] and make sure you catch exceptions. Another way is to check your index values before applying them, so that you never access out of bounds in the first place.