Is it better in C++ to pass by value or pass by constant reference?

by

It used to be generally recommended best practice1 to use pass by const ref for all types, except for builtin types (char, int, double, etc.), for iterators and for function objects (lambdas, classes deriving from std::*_function).

This was especially true before the existence of move semantics. The reason is simple: if you passed by value, a copy of the object had to be made and, except for very small objects, this is always more expensive than passing a reference.

With C++11, we have gained move semantics. In a nutshell, move semantics permit that, in some cases, an object can be passed “by value” without copying it. In particular, this is the case when the object that you are passing is an rvalue.

In itself, moving an object is still at least as expensive as passing by reference. However, in many cases a function will internally copy an object anyway — i.e. it will take ownership of the argument.2

In these situations we have the following (simplified) trade-off:

  1. We can pass the object by reference, then copy internally.
  2. We can pass the object by value.

“Pass by value” still causes the object to be copied, unless the object is an rvalue. In the case of an rvalue, the object can be moved instead, so that the second case is suddenly no longer “copy, then move” but “move, then (potentially) move again”.

For large objects that implement proper move constructors (such as vectors, strings …), the second case is then vastly more efficient than the first. Therefore, it is recommended to use pass by value if the function takes ownership of the argument, and if the object type supports efficient moving.

A historical note:

In fact, any modern compiler should be able to figure out when passing by value is expensive, and implicitly convert the call to use a const ref if possible.

In theory. In practice, compilers can’t always change this without breaking the function’s binary interface. In some special cases (when the function is inlined) the copy will actually be elided if the compiler can figure out that the original object won’t be changed through the actions in the function.

But in general the compiler can’t determine this, and the advent of move semantics in C++ has made this optimisation much less relevant.

1 E.g. in Scott Meyers, Effective C++.

2 This is especially often true for object constructors, which may take arguments and store them internally to be part of the constructed object’s state.

More Related Contents:

  1. Is it better in C++ to pass by value or pass by reference-to-const?
  2. How to pass objects to functions in C++?
  3. Pass by Reference / Value in C++
  4. const vs constexpr on variables
  5. Where should I prefer pass-by-reference or pass-by-value?
  6. Function Overloading Based on Value vs. Const Reference
  7. C++ – passing references to std::shared_ptr or boost::shared_ptr
  8. What exactly is the difference between “pass by reference” in C and in C++?
  9. pass by reference and value with pointers [duplicate]
  10. Pass by reference and value in C++
  11. Does C++ pass objects by value or reference?
  12. Performance cost of passing by value vs. by reference or by pointer?
  13. C++: Why pass-by-value is generally more efficient than pass-by-reference for built-in (i.e., C-like) types
  14. How is its lifetime of a return value extended to the scope of the calling function when it is bound to a const reference in the calling function?
  15. C++ view types: pass by const& or by value?
  16. What operators do I have to overload to see all operations when passing an object to a function?
  17. C++ while loop resetting variables?
  18. why this unexpected variable change happens? [closed]
  19. Const map element access
  20. When do function-level static variables get allocated/initialized?
  21. Functions with const arguments and Overloading
  22. Which is more efficient: Return a value vs. Pass by reference?
  23. changing the value of const variable in C++ [duplicate]
  24. C/C++ changing the value of a const
  25. Easy rule to read complicated const declarations?
  26. What is a constant reference? (not a reference to a constant)
  27. constexpr const vs constexpr variables?
  28. Why is the copy constructor called when we pass an object as an argument by value to a method?
  29. How to convert “pointer to pointer type” to const?
  30. generic way to print out variable name in c++

Leave a Comment