C++ const keyword - use liberally?

Question

In the following C++ functions:

void MyFunction(int age, House &purchased_house)
{
    ...
}


void MyFunction(const int age, House &purchased_house)         


        

Answer 1

Well, as other have already said, from the point of view of C++ language, the above const has no effect on function signature, i.e. the function type remains the same regardless of whether the const is there or not. The only effect it has at the level of abstract C++ language is that you can't modify this parameter inside the function body.

However, at the lower level, the const modifier applied to the parameter value can have some optimization benefits, given a sufficiently clever compiler. Consider two functions with the same parameter set (for simplicity)

int foo(const int a, const double b, const long c) {
   /* whatever */
}

void bar(const int a, const double b, const long c) {
   /* whatever */
}

Let's say somewhere in the code they are called as follows

foo(x, d, m);
bar(x, d, m);

Normally, compilers prepare stack frame with arguments before they call a function. In this case the stack will usually be prepared twice: once for each call. But a clever compiler might realize that since these functions do not change their local parameter values (declared with const), the argument set prepared for the first call can be safely reused for the second call. Thus it can prepare the stack only once.

This is a rather rare and obscure optimization, which can only work when the definition of the function is known at the point of the call (either same translation unit, or an advanced globally-optimizing compiler), but sometimes it might be worth mentioning.

It is not correct to say that it is "worthless" or "has no effect", even though with a typical compiler this might be the case.

Another consideration that is worth mentioning is of different nature. There are coding standards out there, which require coders not to change the initial parameter values, as in "don't use parameters as ordinary local variables, parameter values should remain unchanged throughout the function". This kinda makes sense, since sometimes it makes it easier to determine what parameter values the function was originally given (while in debugger, inside the body of the function). To help enforce this coding standard, people might use const specifiers on parameter values. Whether it is worth it or not is a different question...