Why pass by const reference instead of by value?

by

There are two main considerations. One is the expense of copying the passed object and the second is the assumptions that the compiler can make when the object is a a local object.

E.g. In the first form, in the body of f it cannot be assumed that a and b don’t reference the same object; so the value of a must be re-read after any write to b, just in case. In the second form, a cannot be changed via a write to b, as it is local to the function, so these re-reads are unnecessary.

void f(const Obj& a, Obj& b)
{
    // a and b could reference the same object
}

void f(Obj a, Obj& b)
{
    // a is local, b cannot be a reference to a
}

E.g.: In the first example, the compiler may be able to assume that the value of a local object doesn’t change when an unrelated call is made. Without information about h, the compiler may not know whether an object that that function has a reference to (via a reference parameter) isn’t changed by h. For example, that object might be part of a global state which is modified by h.

void g(const Obj& a)
{
    // ...
    h(); // the value of a might change
    // ...
}

void g(Obj a)
{
    // ...
    h(); // the value of a is unlikely to change
    // ...
}

Unfortunately, this example isn’t cast iron. It is possible to write a class that, say, adds a pointer to itself to a global state object in its constructor, so that even a local object of class type might be altered by a global function call. Despite this, there are still potentially more opportunities for valid optimizations for local objects as they can’t be aliased directly by references passed in, or other pre-existing objects.

Passing a parameter by const reference should be chosen where the semantics of references are actually required, or as a performance improvement only if the cost of potential aliasing would be outweighed by the expense of copying the parameter.

More Related Contents:

  1. Get error say no match for call in c++ [closed]
  2. Questions regarding constructors
  3. does cout before return statement of recursive function stops it?
  4. Possibilities to quit a function
  5. Function does not change passed pointer C++
  6. What is the point of function pointers?
  7. Difference between void main and int main in C/C++? [duplicate]
  8. Overload a C++ function according to the return value
  9. Is the return type part of the function signature?
  10. How to convert a lambda to an std::function using templates
  11. Should I use std::function or a function pointer in C++?
  12. Which is more efficient: Return a value vs. Pass by reference?
  13. How to pass a constant array literal to a function that takes a pointer without using a variable C/C++?
  14. How to cin values into a vector
  15. C++ correct way to return pointer to array from function
  16. Can I set a default argument from a previous argument?
  17. Is it possible to create a function dynamically, during runtime in C++?
  18. How do I return a char array from a function?
  19. How does overloading of const and non-const functions work?
  20. Function returning a lambda expression
  21. Function pointer as parameter
  22. Using boost thread and a non-static class function
  23. Is it legal to use the increment operator in a C++ function call?
  24. Why I can access member functions even after the object was deleted?
  25. C++ Function Callbacks: Cannot convert from a member function to a function signature
  26. How to create a template function within a class? (C++)
  27. switch “transfer of control bypasses initialization of:” when calling a function
  28. Pointing to a function that is a class member – GLFW setKeycallback
  29. Can I treat a specific warning as an error?
  30. Why can’t C++11 move a noncopyable functor to a std::function?

Leave a Comment