What is the difference between const int*, const int * const, and int const *?

Question

Read it backwards (as driven by Clockwise/Spiral Rule):

• int* - pointer to int
• int const * - pointer to const int
• int * const - const pointer to int
• int const * const - const pointer to const int

Now the first const can be on either side of the type so:

• const int * == int const *
• const int * const == int const * const

If you want to go really crazy you can do things like this:

• int ** - pointer to pointer to int
• int ** const - a const pointer to a pointer to an int
• int * const * - a pointer to a const pointer to an int
• int const ** - a pointer to a pointer to a const int
• int * const * const - a const pointer to a const pointer to an int
• ...

And to make sure we are clear on the meaning of const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

foo is a variable pointer to a constant integer. This lets you change what you point to but not the value that you point to. Most often this is seen with C-style strings where you have a pointer to a const char. You may change which string you point to but you can't change the content of these strings. This is important when the string itself is in the data segment of a program and shouldn't be changed.

bar is a constant or fixed pointer to a value that can be changed. This is like a reference without the extra syntactic sugar. Because of this fact, usually you would use a reference where you would use a T* const pointer unless you need to allow NULL pointers.

For those who don't know about Clockwise/Spiral Rule: Start from the name of the variable, move clockwisely (in this case, move backward) to the next pointer or type. Repeat until expression ends.

Here is a demo:

I think everything is answered here already, but I just want to add that you should beware of typedefs! They're NOT just text replacements.

For example:

typedef char *ASTRING;
const ASTRING astring;

The type of astring is char * const, not const char *. This is one reason I always tend to put const to the right of the type, and never at the start.

Like pretty much everyone pointed out:

What’s the difference between const X* p, X* const p and const X* const p?

You have to read pointer declarations right-to-left.

• const X* p means "p points to an X that is const": the X object can't be changed via p.

• X* const p means "p is a const pointer to an X that is non-const": you can't change the pointer p itself, but you can change the X object via p.

• const X* const p means "p is a const pointer to an X that is const": you can't change the pointer p itself, nor can you change the X object via p.

1. Constant reference:

   A reference to a variable (here int), which is constant. We pass the variable as a reference mainly, because references are smaller in size than the actual value, but there is a side effect and that is because it is like an alias to the actual variable. We may accidentally change the main variable through our full access to the alias, so we make it constant to prevent this side effect.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK
   

2. Constant pointers

   Once a constant pointer points to a variable then it cannot point to any other variable.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error
   

3. Pointer to constant

   A pointer through which one cannot change the value of a variable it points is known as a pointer to constant.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error
   

4. Constant pointer to a constant

   A constant pointer to a constant is a pointer that can neither change the address it's pointing to and nor can it change the value kept at that address.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error
   

The general rule is that the const keyword applies to what precedes it immediately. Exception, a starting const applies to what follows.

• const int* is the same as int const* and means "pointer to constant int".
• const int* const is the same as int const* const and means "constant pointer to constant int".

Edit: For the Dos and Don'ts, if this answer isn't enough, could you be more precise about what you want?