Why call by reference is more prefareble than call by value?

Answer 1

Pass by reference is preferable when we need to pass an object that is too large to fit into a CPU register. Typically this means any object of a type larger than a pointer. When we pass large objects by value, a new object is copy constructed from the object's value, and that can have a serious impact on performance. Passing by reference ensures that no copy is made; we're simply passing the object's memory address, which is guaranteed to fit in a CPU register.

Ideally we should pass by constant reference because users do not expect functions to have side-effects. If a function needs to alter the value of its argument, then it should use the pass by value semantic. If we need to return the modified value back to the caller, it should use the return value. With appropriate move semantics, returning objects by value has minimal impact and eliminates all side-effects:

class X {

public:

X (const X&); // copy construct

X& operator= (const X&); // copy assign

X (X&&); // move construct X& operator= (X&&); // move assign

// ...

};

X use (X obj) { // pass by value (invokes copy constructor)

// modify obj...

return obj; // return by value (invokes move constructor)

}

X x1;

x1 = use (x1);

Passing by non-const reference to achieve the same end can have a (slight) performance advantage, however passing by value ensures the caller is wholly responsible for any side-effects and not the function. If a function has side-effects, we need to know what they are, but we don't always have access to the source code, so passing by value or by const reference ensures there aren't any side-effects.