Parameter Passing Etiquette (C++) const& vs. value - c++

Question

If all a function needs to do with a parameter is see its value, shouldn't you always pass that parameter by constant reference?
A colleague of mine stated that it doesn't matter for small types, but I disagree.
So is there any advantage to do this:
void function(char const& ch){ //<- const ref
if (ch == 'a'){
DoSomething(ch);
}
return;
}
over this:
void function(char ch){ //<- value
if (ch == 'a'){
DoSomething(ch);
}
return;
}
They appear to be the same size to me:
#include <iostream>
#include <cstdlib>
int main(){
char ch;
char& chref = ch;
std::cout << sizeof(ch) << std::endl; //1
std::cout << sizeof(chref) << std::endl; //1
return EXIT_SUCCESS;
}
But I do not know if this is always the case.
I believe I'm right, because it does not produce any additional overhead and it is self documenting.
However, I want to ask the community if my reasoning and assumptions are correct?

Answer 1

Your colleague is correct. For small types (char, int) it makes no sense to pass by reference, when the variable is not to be modified. Passing by value would be better, as size of pointer (used in case of passing by reference) is about the size of small types.
And moreover, passing by value, is lesser typing, as well as slightly more readable.

Answer 2

Even though the sizeof(chref) is the same as sizeof(ch), passing character by reference does take more bytes on most systems: although the standard does not say anything specific about the implementation of references, an address (i.e. a pointer) is regularly passed behind the scenes. With optimization on, it probably would not matter. When you code template functions, items of unknown type that will not be modified should always be passed by const reference.
As far as small types go, you can pass them by value with a const qualifier to emphasize the point that you aren't going to touch the argument through the signature of your function:
void function(const char ch){ //<- value
if (ch == 'a'){
DoSomething(ch);
}
return;
}

Answer 3

For small values, the cost of creating a reference and dereferencing it is likely to be greater than the cost of copying it (if there is a difference at all). This is especially true when you consider that reference parameters are pretty much always implemented as a pointer. Both document equally well if you just declare your value as const (I'm using this value for input only and it will not be modified). I generally just make all of the standard built-in types by const value and all user-defined / STL types as const &.
Your sizeof example is flawed because chref is just an alias for ch. You'd get equal results for sizeof(T) for any type T.

Answer 4

The sizes are not the same as passed. The result depends on the ABIs calling convention, but the sizeof(referenceVariable) produces the sizeof(value).
If all a function needs to do with a parameter is see its value, shouldn't you always pass that parameter by constant reference?
That's what I do. I know people disagree with me, and argue for passing small builtins by value, or prefer to omit the const. Passing by reference can add instructions and/or consume more space. I pass this way for consistency, and because always measuring the best way to pass for any given platform is a lot of hassle to maintain.
There isn't an advantage beyond readability (if that's your preference). Performance could suffer very slightly, but it will not be a consideration in most cases.
Passing these small builtins by value is more common. If passing by value, you can const qualify the definition (independent of the declaration).
My recommendation is that the vast majority of teams should simply choose one way to pass and stick with it, and performance should not influence that unless every instruction counts. The const never hurts.

Answer 5

In my opinion, your general approach of passing by const reference is a good practice (but see below for some caveats on your example). On the other hand, your friend is correct that for built-in types, passing by reference should not result in any significant performance gains, and could even result in marginal performance losses. I come from a C background, so I tend to think of references in terms of pointers (even though there are some subtle differences), and a "char*" will be bigger than a "char" on any platform with which I'm familiar.
[EDIT: removed incorrect information.]
The bottom line, in my opinion, is that when you're passing larger user-defined types, and the called function only needs to read values without modifying them, passing by "type const&" is a good practice. As you say, it's self-documenting, and helps clarify the roles of the various pieces of your internal API.