Const Parameters
================

Consider the following trivial function

     int f( int x, int y )
     {
         return x + y;  // Changes neither x nor y.
     }

Since x and y are not modified they could be const so why not write

     int f( const int x, const int y )
     {
         return x + y;
     }

Here the parameters themselves are constants; this has nothing to do with the arguments. In C
(and C++) the parameters are initialized with copies of the arguments. When you call f like this

     f( a, b );

it's kind of like doing

     const int x = a;
     const int y = b;

at the top level of the function. That is, the parameters x and y are constant objects that are
copies of a and b.

Okay... so is this good practice? It depends on who you ask. There is a school of thought that
says, "make everything const that you can." This is based on the idea that immutable values are
easier to reason about. People like this feel that everything should be const by default and you
should have to do something special to get a non-const. People like this want to be programming
in a pure functional language.

It's a good idea!

On the other hand... some (many) say that declaring parameters const is overkill. It makes the
readers of your program go "huh?" which is bad for understandability. In fact, quite a few C/C++
programmers don't even realize you can declare parameters as const. Consider this;

     int f( int x, int y );  // Declaration of f. Can't use const here.

     // Implementation of f. Use of const okay here. The const is only
     // relevant inside the function (like const on a local variable).
     //
     int f( const int x, const int y )
     {
         return x + y;
     }

It doesn't help that some compilers have bugs in this area and (incorrectly) call the
implementation of f above wrong because it is "inconsistent" with the declaration (it isn't).

Take care: there is a big difference between this

     int f( const int *x ) { ... }

and

     int f( const int x ) { ... }

In the first case the parameter is not const (the thing it points at is a const). In the second
case it's the parameter itself that is const. If one asks, "is it sensible to make parameters
const when possible?" and the answer is this long winded message. However, if one asks, "is it
sensible to make pointer parameters pointer to const when possible?" the answer is a resounding
YES! Always make pointer (or reference) parameters pointers (or references) to const when it
makes sense to do so.