An operation like a + c can often be implemented slightly faster if c is a constant that is known to the compiler because it can be made part of the instruction. Also if a value is known to be unchanged that gives opportunities to an optimising compiler. In the extreme case, if you calculate a*c and know that c is the constant 1.0, you don't even to multiply.
There are exceptions: Some compilers seem to believe that constants are always faster. If a variable like c is used often, it gets loaded into a register and stays there. If c is a constant, the compiler loads it every single time it is used. I've had time critical code where execution time improved significantly when I convinced the compiler that a constant value might change (storing a constant into a variable didn't help because the compiler figured out the value never changed).
This is a compiler limitation. The point is: It's very hard to predict what exactly will run faster. And it can change as processors change, or as compilers change.