Please refer the following link for better understanding about the difference between Const pointer and Pointer on a constant value.
Referncing from
This Thread
Constant Pointers
Lets first understand what a constant pointer is. A constant pointer is a pointer that cannot change the address its holding. In other words, we can say that once a constant pointer points to a variable then it cannot point to any other variable.
A constant pointer is declared as follows :
<type of pointer> * const <name of pointer>
An example declaration would look like :
int * const ptr;
Lets take a small code to illustrate these type of pointers :
#include<stdio.h>
int main(void)
{
int var1 = 0, var2 = 0;
int *const ptr = &var1;
ptr = &var2;
printf("%d\n", *ptr);
return 0;
}
In the above example :
Pointer to Constant
As evident from the name, a pointer through which one cannot change the value of variable it points is known as a pointer to constant. These type of pointers can change the address they point to but cannot change the value kept at those address.
A pointer to constant is defined as :
const <type of pointer>* <name of pointer>
An example of definition could be :
const int* ptr;
Lets take a small code to illustrate a pointer to a constant :
#include<stdio.h>
int main(void)
{
int var1 = 0;
const int* ptr = &var1;
*ptr = 1;
printf("%d\n", *ptr);
return 0;
}
In the code above :
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_pointer
constant_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_constant
pointer_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.
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.
const int* ptr;
is a pointer to constant (content). You are allowed to modify the pointer. e.g. ptr = NULL
, ptr++
, but modification of the content is not possible.
int * const ptr;
Is a constant pointer. The opposite is possible. You are not allowed to modify the pointer, but you are allowed to modify what it points to e.g. *ptr += 5
.
int i;
int j;
int * const ptr1 = &i;
The compiler will stop you changing ptr1
.
const int * ptr2 = &i;
The compiler will stop you changing *ptr2
.
ptr1 = &j; // error
*ptr1 = 7; // ok
ptr2 = &j; // ok
*ptr2 = 7; // error
Note that you can still change *ptr2
, just not by literally typing *ptr2
:
i = 4;
printf("before: %d\n", *ptr2); // prints 4
i = 5;
printf("after: %d\n", *ptr2); // prints 5
*ptr2 = 6; // still an error
You can also have a pointer with both features:
const int * const ptr3 = &i;
ptr3 = &j; // error
*ptr3 = 7; // error
const int* ptr;
here think like *ptr is constant and *ptr can't be change again
int * const ptr;
while here think like ptr as a constant and that can't be change again
Source: Stackoverflow.com