In C++, why shouldn't all function parameters be references?

Question

I am currently learning C++ from the C++ Primer 5th edition. The book's chapter on functions states that only large objects (large being relative as standard library strings count, but "primitive types" such as int or char don't) should be passed as references.

For instance, the following function serves as an example in the book on when to use reference parameters:

string::size_type find_char(const string &s, char c, string::size_type &occurs){
    /* code to return the first occurrence of c in s, occurs contains total number of occurrences */
}

One of the exercises asks what the rationale for each of the parameter being what it is beyond it's base type. I understand why the string is a reference (to prevent copying of to improve performance) and why it is const (as it doesn't need to be modified). I also understand why the occurs parameter is a reference (as the original variable's value needs to be changed).

What I don't understand is why c isn't a (const) reference. I know that it contains a very small object, but, wouldn't the prevention of any object from being copied, no matter how small, still be a performance improvement?

If there was some downside to using references, then it would make sense. But, I have no idea what such a downside would be. Also, I know that a pointer's address would be copied, but, since references can't be changed I imagine that the called function could access the original variable in exactly the same way that the caller does (assuming that the variable is declared in the caller).

Why should a non-reference parameter ever be used, especially in instances like the above example, unless the parameter needs to be modified for the function's implementation without returning the changed value?

NOTE: The function body is included in the book, but, is removed from this question for brevity.

Answer 1

For basic types, reference parameters usually offer no performance attribute at all.

Memory

For instance, in your example, the char requires a single byte. A reference type requires a pointer, which is usually either 4 or 8 bytes, where the size of a pointer directly correlates to the type of executable you are using (4 bytes for 32 bit, 8 bytes for 64 bit), due to the size of the memory register.

For most modern machines, this will be passed either on the stack, or in a register, as a single value. So it really makes no difference at all.

Time

Copying a basic type (char, int, long) is usually a single MOV instruction. Setting the pointer used in a reference parameter is, again, usually a single MOV instruction.

Answer 2

There are two major downsides to using references:

1. Using references allows for additional aliasing. This means the compiler has to re-load and store the value more often unless it can in some other way determine that a value is not read / written between two uses in the code it sees.

2. Every indirection means additional reading of memory.

In any type which uses small-buffer-optimization, like most versions of std::string, there is an additional reason:

3. Getting the start and size of the sequence is not just a trivial memory read, but depends on whether the internal buffer is engaged, or external space was needed.

In many cases, these effects dominate any potential saving from not having to copy the argument, even if the type is slightly bigger than a pointer. Not that there is any such saving for trivially-copyable types no bigger than a pointer.

As an aside, since C++17 you should avoid passing a const std::string& in favor of a std::string_view:

The latter is more flexible and efficient, as it does not allocate the string, reduces indirection, and has no allocation-policy.

Answer 3

Your first parameter s, you don’t really want a const reference, you want a value. For example, s bring a reference means the string could me modified or deleted by another thread.

The only reason why you pass it as a const reference is performance. For c there is no performance gain by passing it as a reference so it’s not done. “occurs” is a reference because you want two return values in your function but you can use only one. I actually dislike this very much because a variable can/will be modified without anything visible in the call.

If you look at a language like Swift that is about 30 years newer. String is passed by value - but creating a copy is fast by using copy-on-write. A function can return multiple values. So no references are needed at all.

Answer 4

My understanding is that you want to "encapsulate" the arguments you pass to a function - the function should be able to modify only what you want it to modify. Always passing a reference and putting const in front of it is tedious and prone to errors.

Also, always passing references would mean creating a local variable for each function argument (instead of passing expressions).

In addition, passing a reference means the compiler will probably need to generate code for dereferencing in the called function. For some ABIs passing a reference may be significantly slower.