Would a pre-calculated variable faster than calculating it every time in a loop?

In a function that updates all particles I have the following code:

for (int i = 0; i < _maxParticles; i++)
{
    // check if active
    if (_particles[i].lifeTime > 0.0f)
    {
        _particles[i].lifeTime -= _decayRate * deltaTime;
    }
}

This decreases the lifetime of the particle based on the time that passed. It gets calculated every loop, so if I've 10000 particles, that wouldn't be very efficient because it doesn't need to(it doesn't get changed anyways).

So I came up with this:

float lifeMin = _decayRate * deltaTime;

for (int i = 0; i < _maxParticles; i++)
{
    // check if active
    if (_particles[i].lifeTime > 0.0f)
    {
        _particles[i].lifeTime -= lifeMin;
    }
}

This calculates it once and sets it to a variable that gets called every loop, so the CPU doesn't have to calculate it every loop, which would theoretically increase performance.

Would it run faster than the old code? Or does the release compiler do optimizations like this?

I wrote a program that compares both methods:

#include <time.h>
#include <iostream>

const unsigned int MAX = 1000000000;

int main()
{
    float deltaTime = 20;
    float decayRate = 200;

    float foo = 2041.234f;

    unsigned int start = clock();

    for (unsigned int i = 0; i < MAX; i++)
    {
        foo -= decayRate * deltaTime;
    }

    std::cout << "Method 1 took " << clock() - start << "ms\n";

    start = clock();

    float calced = decayRate * deltaTime;

    for (unsigned int i = 0; i < MAX; i++)
    {
        foo -= calced;
    }

    std::cout << "Method 2 took " << clock() - start << "ms\n";

    int n;
    std::cin >> n;
    return 0;
}

Result in debug mode:

Method 1 took 2470ms
Method 2 took 2410ms

Result in release mode:

Method 1 took 0ms
Method 2 took 0ms

But that doesn't work. I know it doesn't do exactly the same, but it gives an idea. In debug mode, they take roughly the same time. Sometimes Method 1 is faster than Method 2(especially at fewer numbers), sometimes Method 2 is faster. In release mode, it takes 0 ms. A little weird.

I tried measuring it in the game itself, but there aren't enough particles to get a clear result.

EDIT I tried to disable optimizations, and let the variables be user inputs using std::cin. Here are the results:

Method 1 took 2430ms
Method 2 took 2410ms