C++ Pass By Const Reference and Return By Const Reference

Question

I'm trying to understand if there is any benefit to returning a const reference. I have a factorial function that normally looks like this:

unsigned long factorial(unsigned long n)
{
    return (n == 0) ? 1 : n * factorial(n - 1);
}

I'm assuming that there will be a performance increase when we pass by const reference and we return a const reference... but const-correctness always confuses me.

const unsigned long & factorial(const unsigned long& n)
{
    return (n == 0) ? 1 : n * factorial(n - 1);
}

Is it valid to return a const reference? Furthermore, could somebody please tell me: is it beneficial?

Answer 1

This is invalid. You can't return reference to a local variable.

MSVS C++ compiler even gives the following warning:

main.cc : warning C4172: returning address of local variable or temporary

Not quite sure about GCC, but probably the result would be the same.

Answer 2

A const reference isn't faster than a value, if the size of the value is small. In this case the type of the value is long, which is IMO small (e.g. 4 to 8 bytes): so a const reference will be no faster. In fact it may be slower, because to get the value of a reference the compiler may need to emit the code that will dereference the reference (like dereferencing a pointer).

Given that a reference is implemented (internally) like a pointer, I'd expect to get better performance from passing references than from passing values when the size of the value is bigger than the size of a pointer (assuming that it's even legal to pass a reference: a reference to a local variable that's gone out of scope isn't legal).

Answer 3

The const reference is incorrect here - you're returning a reference to a local variable - an un-named temporary here, either 1 or the result of n * factorial(n - 1). Because the reference is to a local variable in the function, by the time the reference gets to the caller, that local variable has already gone out of scope, and is invalid.

Return a const reference to large structured types that you want to avoid a copy to when the reference will survive the exit of the function. Usually, this means returning a reference to an argument or to a member variable (in the case of classes).