Difference between const reference and normal parameter

Question

void DoWork(int n); void DoWork(const int &n); 

What's the difference?

Answer 1

The important difference is that when passing by const reference, no new object is created. In the function body, the parameter is effectively an alias for the object passed in.

Because the reference is a const reference the function body cannot directly change the value of that object. This has a similar property to passing by value where the function body also cannot change the value of the object that was passed in, in this case because the parameter is a copy.

There are crucial differences. If the parameter is a const reference, but the object passed it was not in fact const then the value of the object may be changed during the function call itself.

E.g.

int a;  void DoWork(const int &n) {     a = n * 2;  // If n was a reference to a, n will have been doubled       f();  // Might change the value of whatever n refers to  }  int main() {     DoWork(a); } 

Also if the object passed in was not actually const then the function could (even if it is ill advised) change its value with a cast.

e.g.

void DoWork(const int &n) {     const_cast<int&>(n) = 22; } 

This would cause undefined behaviour if the object passed in was actually const.

When the parameter is passed by const reference, extra costs include dereferencing, worse object locality, fewer opportunities for compile optimizing.

When the parameter is passed by value an extra cost is the need to create a parameter copy. Typically this is only of concern when the object type is large.

Answer 2

The difference is more prominent when you are passing a big struct/class:

struct MyData {     int a,b,c,d,e,f,g,h;     long array[1234]; }; void DoWork(MyData md); void DoWork(const MyData& md); 

When you use use 'normal' parameter, you pass the parameter by value and hence creating a copy of the parameter you pass. If you are using const reference, you pass it by reference and the original data is not copied.

In both cases, the original data cannot be modified from inside the function.

---

EDIT:
In certain cases, the original data might be able to get modified as pointed out by Charles Bailey in his answer.