In C++, you can declare variables as constants. Such a variable need to be initialized with a constant value when it is declared. Constant variable cannot be assigned other values. But why do we need such a feature in the programming language? Why not handle this limitation in a document around it? Say, declare a variable, define it or initialize it with a value, add a remainder in the code itself, that this variable cannot hold some other value. Why not?
The answer lies in the fact that more than one person is involved in developing a piece of software. In most cases, the team writing interfaces or frameworks are not the same consuming it. So, programming languages have included a syntax in them to declare constant variables and if any other person tries to break it, compiler itself will stop it. This will ensure consistency and integrity of the software from conception to finish.
Let us see how constants are realized in C++ programming language.
You want to declare a integer constant variable? Here it is :
const int number_of_days_in_a_year = 365;
Let us try couple of things:
Later in the code,
number_of_days_in_a_year = 366;
Or declare constant variable without a initialized value:
const int number_of_days_in_a_year;
Compiler will complain in both cases for obvious reasons.
How about pointers? How do I declare and define a pointer, pointing to a constant variable? This is important because, you can modify a variable using its pointer. Here is how you declare and define a pointer, pointing to a constant variable:
const int *pointer_to_variable = &number_of_days_in_a_year;
Now, any attempt to modify the variable using pointer, will not be liked by compiler.
*pointer_to_variable = 366;
Compiler would complain that a value cannot be assigned to read-only variable.
But here is a trick. What about I declare a non-constant variable, but define its pointing pointer as constant?
int myvariable = 7;
const int *pointer_to_myvariable = &myvariable;
Surprise!, Compiler will be happy with it. But here are the consequences:
myvariable = 9;
*pointer_to_myvariable = 9; // BAD!
Assigning myvariable to a value other than 7 is fine with compiler, as the variable itself is not constant. Howerver, assigning a value to the same using ‘pointer, pointing to a constant’ is not allowed, as the pointer is declared as pointing to a constant.
How about declaring a constant variable and a pointer pointing to the variable as non-constant?
const int hour_in_a_day = 24;
int *pointer_to_hour_in_a_day = &hour_in_a_day; // BAD!
Luckily, unlike the previous case, compiler would complain with pointer declaration! “int *” is not compatible with “constant int *” will be the explanation.
Until now, we discussed pointer pointing to constant. But the pointer itself can be a constant. Here is how a constant pointer can be declared and defined:
int myvariable1 = 91;
int myvariable2 = 92;
int * const mypointer = &myvariable1;
*mypointer = 93;
mypointer is a ‘constant’ pointer, pointing to myvariable. It does not matter if myvariable1 is constant or not. In the example above, myvariable1 is not a constant. mypointer is not designed to point to a constant, so the variable can be changed to 93 via pointer.
Any attempt to switch mypointer to point to another variable will be fatal
mypointer = &myvariable2; // BAD!
Finally, lets put them together, a constant variable, constant pointer, pointing to constant.
const int myvariable1 = 91;
const int myvariable2 = 92;
const int * const mypointer = &myvariable1;
All of the below mentioned attempts will be erroneous:
myvriable1 = 92; // BAD!
*mypointer = 92; // BAD!
mypointer = &myvariable2; // BAD!
