Constant pointer vs Pointer to constant [duplicate]

const int* ptr; 

declares ptr a pointer to const int type. You can modify ptr itself but the object pointed to by ptr shall not be modified.

const int a = 10;const int* ptr = &a;  *ptr = 5; // wrongptr++;    // right  

While

int * const ptr;  

declares ptr a const pointer to int type. You are not allowed to modify ptr but the object pointed to by ptr can be modified.

int a = 10;int *const ptr = &a;  *ptr = 5; // rightptr++;    // wrong

Generally I would prefer the declaration like this which make it easy to read and understand (read from right to left):

int const  *ptr; // ptr is a pointer to constant int int *const ptr;  // ptr is a constant pointer to int

const int * ptr;

means that the pointed data is constant and immutable but the pointer is not.

int * const ptr;

means that the pointer is constant and immutable but the pointed data is not.

1) Constant Pointers : These type of pointers are the one which cannot change address they are pointing to. This means that suppose there is a pointer which points to a variable (or stores the address of that variable). Now if we try to point the pointer to some other variable (or try to make the pointer store address of some other variable), then constant pointers are incapable of this.

A constant pointer is declared as : int *const ptr ( the location of 'const' make the pointer 'ptr' as constant pointer)

2) Pointer to Constant : These type of pointers are the one which cannot change the value they are pointing to. This means they cannot change the value of the variable whose address they are holding.

A pointer to a constant is declared as : const int *ptr (the location of 'const' makes the pointer 'ptr' as a pointer to constant.

Example

Constant Pointer

#include<stdio.h>int main(void){    int a[] = {10,11};    int* const ptr = a;    *ptr = 11;    printf("\n value at ptr is  : [%d]\n",*ptr);    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);    ptr++;    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);    return 0;}

Now, when we compile the above code, compiler complains :

practice # gcc -Wall constant_pointer.c -o constant_pointerconstant_pointer.c: In function ‘main’:constant_pointer.c:13: error: increment of read-only variable ‘ptr’

Hence we see very clearly above that compiler complains that we cannot changes the address held by a constant pointer.

Pointer to Constants

#include<stdio.h>int main(void){    int a = 10;    const int* ptr = &a;    printf("\n value at ptr is  : [%d]\n",*ptr);    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);    *ptr = 11;    return 0;}

Now, when the above code is compiled, the compiler complains :

practice # gcc -Wall pointer_to_constant.c -o pointer_to_constantpointer_to_constant.c: In function ‘main’:pointer_to_constant.c:12: error: assignment of read-only location ‘*ptr’

Hence here too we see that compiler does not allow the pointer to a constant to change the value of the variable being pointed.

Quotation