What is a pointer constant?

Answer 1

In programming, a pointer is a variable that stores a memory address. We say that the variable 'points at' the memory address, because we can access that memory indirectly via the pointer variable. And since they are variable, we can change the address stored in the pointer at any time.

A constant pointer, on the other hand, is a pointer that is guaranteed to always point at the same memory address it was given when it was first instantiated. That memory address cannot be altered until the pointer falls from scope, at which point it can be re-instantiated with a different memory address. But while it is in scope, it cannot be altered.

Note that a constant pointer is not the same as a pointer to a constant. A pointer to a constant is still a variable, only the memory being pointed at is regarded as being constant. That is, we can change the memory address stored in the pointer, but we cannot change what is stored in that memory address.

To better understand the difference, consider the following declarations in C++ code:

int x[2] = { 1, 2 };

int* p1 = &x[0];

const int* p2 = &x[0];

int* const p3 = &x[0];

const int* const p4 = &x[0];

Here, p1, p2, p3 and p4 are all declared as pointers to integers while x is an integer array with two elements. x[0] is the first element, with value 1, while x[1] is the second element, with value 2. All four pointers initially point at the address occupied by x[0] and all can indirectly access the value contained therein.

p1 is declared as a pointer to an integer. Neither the pointer nor the integer are declared constant, so this means we can use pointer arithmetic on the pointer, incrementing it so it points at x[1], and we can also alter the value of the integer contained therein via the indirection operator:

p1++; // point to x[1]

(*p1)++; // indirectly increment the value of x[1]; so 2 becomes 3

p2 is declared as a pointer to a constant integer so we can adjust the pointer, but we cannot alter the value being pointed at:

p2++; // point to x[1]

(*p2)++; // illegal; x[1] still has the value 3!

p3 is declared as a constant pointer to an integer, so we cannot adjust the pointer but we can adjust the value being pointed at:

p3++; // illegal; still points to x[0]!

(*p3)++; // indirectly increment the value of x[0], so 1 is now 2

p4 is declared as a constant pointer to a constant integer, so we cannot adjust either the pointer or the value being pointed at:

p4++; // illegal; still points to x[0]!

(*p4)++; // illegal; x[0] still has the value 2!

In other words, p1 and p2 are pointer variables, while p3 and p4 are both constant pointers. Note that you will quite often hear people calling p2 a constant pointer but it is actually a pointer to a constant. In that variation it is the memory being pointed at that is regarded as being the constant, not the pointer itself.

Of course the illegal statements would not be permitted in legitimate code -- the compiler will warn us that the variables we are attempting to modify are in fact qualified as being constant and therefore cannot be modified. However, this is the one and only reason we use constants; to alert us to inadvertent bugs in our code. When we declare a constant, we are enlisting the aid of the compiler to assure us that we do not inadvertently alter variables that should not be altered. The more bugs we can catch with the compiler's help, the better. If only runtime bugs could be resolved as easily.