Under what scenarios would you declare a non-reference, non-pointer type function parameter const?

Question

I have the following function declaration:

void fn(int);

This function has a single integral type parameter. Now, I could call this function by passing a non const or a const integral object. In either case, this function is going to copy the object to its local int parameter. Therefore, any modifications to this parameter is going to be local to the function and is not going to affect the actual arguments of the caller in any way. Now my question is under which scenario will I declare this single int parameter to be of const type? I don't see a need to declare this function as follows.

void fn(const int);

This is because the arguments are going to be anyway passed by value and the function can in no way modify the arguments in either case. I understand that by declaring a parameter constant the function cannot modify it inside its body. However, there is no downside here even if the function modifies since the parameter is local to the function.

Answer 1

You're right that to the caller there is no difference -- it only matters inside the function. I prefer to add the const whenever I can. As I'm writing the function, I'm thinking "I want this parameter but have no intention of modifying it (even just locally)" and the compiler will keep me honest.

Also, in some cases the compiler may be able to do more optimizations if it knows the variable is const (as in loop bounds).

Answer 2

Sometimes templates are written in a general way, and end up doing things like that. With function template parameter deduction, though, that const tends to get thrown away.

this is effectively a const argument. It is a pointer, but it's immutable in the sense of your example. (Of course, this is a keyword, not a variable, and unary & doesn't work with it.) If you want an argument to behave like that, declare it const.

Answer 3

Just because it's allowed, doesn't mean there's a point to it.

I wouldn't be surprised if this could cause overloading to behave slightly differently, but I think you're basically right - there's no good outside-the-function reason to do it.

One possible problem is confusing readers who might think you intended a reference instead, but forgot the "&".

Answer 4

From the C++ Spec: http://www.kuzbass.ru:8086/docs/isocpp/over.html

Parameter declarations that differ only in the presence or absence of const and/or volatile are equivalent. That is, the const and volatile type-specifiers for each parameter type are ignored when determining which function is being declared, defined, or called.

Example:

typedef const int cInt;

int f (int);
int f (const int);              //  redeclaration of  f(int)
int f (int) { ... }             //  definition of  f(int)
int f (cInt) { ... }            //  error: redefinition of  f(int)

Answer 5

A favorite interview question in C++ interview is what is the difference between passing by values, passing by pointer and passing by reference.

In this case we are passing by value and that too int and hence it will not matter. But I am not sure about the user created classes. In that case when the compiler see the object is passed by const value it may decide to pass it by the const reference. Nowdays compilers are intelligent and I don't see why they can not do it.