Today I had some time to verify an idea I have always had: in C++ it
is better to avoid unnecessary references when passing double
arguments to functions.
The idea to verify this came while I was inspecting some C++ code. One
of the functions had a parameter which was declared as double &
despite the fact that such parameter was never changed in the function
body. Consider this example:
The problem with the double & lies in the fact that the function
receives a pointer to double instead of a double: therefore it has to
look for the value pointed by the argument and copy it into a
floating-point register:
Had we defined doubleThis with a double parameter (without the &
indicating a reference) like this:
then GCC would have produced the following assembly code:
which is shorter and faster.
In short: avoid using unnecessary references. Apart from the fact that
they obfuscate the meaning of the function (a reference parameter
indicates that the function is going to alter its contents, while this
is not true for doubleThis), depending on the type of the parameter
they might also produce slower code.
