Question

This might be a stupid question, but I notice that in a good number of APIs, a lot of method signatures that take integer parameters that aren’t intended to be modified look like:

void method(int x);

rather than:

void method(const int &x);

To me, it looks like both of these would function exactly the same. (EDIT: apparently not in some cases, see answer by R Samuel Klatchko) In the former, the value is copied and thus can’t change the original. In the latter, a constant reference is passed, so the original can’t be changed.

What I want to know is why one over the other – is it because the performance is basically the same or even better with the former? e.g. passing a 16-bit value or 32-bit value rather than a 32-bit or 64-bit address? This was the only logical reason I could think of, I just want to know if this is correct, and if not, why and when one should prefer int x over const int &x and vice versa.

Answer 1

It’s not just the cost of passing a pointer (that’s essentially what a reference is), but also the de-referencing in the called method’s body to retrieve the underlying value.

That’s why passing an int by value will be virtually guaranteed to be faster (Also, the compiler can optimize and simply pass the int via processor registers, eliminating the need to push it onto the stack).