Skip to main content

constant pointer, pointer to a constant and constant pointer to a constant

const pointer, pointer to a constant and const pointer to a constant:
If a pointer declaration contains const type qualifier, then it would be either const pointer or pointer to constant or constant pointer to a constant.

const pointer:
What is constant pointer?
A constant pointer is a pointer whose value(address to which the pointer points to) cannot be changed after initialization.  But, we can change the value(pointee) to which the pointer points to.

How to declare constant pointer?
The qualifier const needs to be located in between the asterisk and pointer name.

     int      * const ptr;
    <type> * const <pointer-name>


Below is an example program for constant pointers.

  /* constant pointer */
  #include <stdio.h>
  int main() {
        int num1 = 10, num2 = 20;
        int * const ptr = &num1;
        printf("ptr: 0x%x\t *ptr: %d\n", (int)ptr, *ptr);
        /* trying to change the value of const pointer */
        ptr = &num2;
        printf("ptr: 0x%x\t *ptr: %d\n", (int)ptr, *ptr);
        return 0;
  }



  Output:
  jp@jp-VirtualBox:~/$ gcc -Wall constptr.c 
  constptr.c: In function ‘main’:
  constptr.c:7: error: assignment of read-only variable ‘ptr’


We are trying to alter the value of the pointer after initialization.  That's the reason for the above error message.  Basically, we cannot change the value of the const pointer after initialization.




  /* constant pointer */
  #include <stdio.h>
  int main() {
        int num1 = 10;
        /* const pointer initialization */
        int * const ptr = &num1;
        printf("ptr: 0x%x\t *ptr: %d\n", (int)ptr, *ptr);
        /* changing the value at the address in pointer  */
        *ptr = 20;
        printf("ptr: 0x%x\t *ptr: %d\n", (int)ptr, *ptr);
        return 0;
  }




  Output:
  jp@jp-VirtualBox:~/$ gcc -Wall constptr.c 
  jp@jp-VirtualBox:~/$ ./a.out
  ptr: 0xbfb0795c *ptr: 10
  ptr: 0xbfb0795c *ptr: 20


The above program explains that we can alter the value to which a const pointer points to(in the case of constant pointer).



Pointer to constant:
What is pointer to constant?
Pointer to a constant is nothing but the value to which a pointer refers to cannot be changed after initialization.

How to declare pointer to constant?
The qualifier const needs to be located before the type of the pointer variable.

      const   int      * ptr;
      const <type>  * <pointer-name>


Below is an example program for pointer to constant.

  #include <stdio.h>
  int main() {
        int num = 10;
        const int * ptr = &num;
        /* changing the value at the address in pointer */
        *ptr = 20;
        printf("ptr: 0x%x\t*ptr: %d\n", (int)ptr, *ptr);
        return 0;
  }



  Output:
  jp@jp-VirtualBox:~/$ gcc ptr2const.c 
  ptr2const.c: In function ‘main’:
  ptr2const:6: error: assignment of read-only location ‘*ptr’


We are trying to alter the value(constant) to which the pointer points to.  That's the reason for the above error message.  Basically, the value to which the pointer points to cannot be altered in the case of pointer to a constant.


  #include <stdio.h>
  int main() {
        int num1 = 10, num2 = 20;
        const int * ptr = &num1;
        printf("ptr: 0x%x\t*ptr: %d\n", (int)ptr, *ptr);
        /* changing the pointer value */
        ptr = &num2;
        printf("ptr: 0x%x\t*ptr: %d\n", (int)ptr, *ptr);
        return 0;
  }



  Output:
  jp@jp-VirtualBox:~/$ gcc -Wall ptr2const.c
  jp@jp-VirtualBox:~/$ ./a.out
  ptr: 0xbfa1103c *ptr: 10
  ptr: 0xbfa11038 *ptr: 20


The above program explains that the pointer value can be altered in the case of pointer to a constant.



constant pointer to a constant:
What is constant pointer to a constant?
If the value of the pointer and pointee(the value to which pointer points to) cannot be altered after initialization, then it called constant pointer to a constant.

How to declare constant pointer to a constant?
The const qualifier needs to be located at two places as shown below.

     const  int      *  const    ptr;
     const <type> *  const  <pointer-name>;


Below is an example program for constant pointer to a constant.

  #include <stdio.h>
  int main() {
        int num1 = 10, num2 = 20;
        const int * const ptr = &num1;
        /* changing the pointee value */
        *ptr = 30;
        /* changing the pointer value */
        ptr = &num2;
        return 0;
  }



  Output:
  jp@jp-VirtualBox:~/cpgms/pointers$ gcc -Wall cptr2const.c 
  cptr2const.c: In function ‘main’:
  cptr2const.c:6: error: assignment of read-only location ‘*ptr’
  cptr2const.c:8: error: assignment of read-only variable ‘ptr’


We have tried to modify the value of pointer and pointee.  That's the reason for the above error message.  We cannot alter neither pointer nor pointee in the case of constant pointer to a constant.

Labels:

Comments

Post a Comment

Popular posts from this blog

Array of pointer to structure

Array of pointer to structure is nothing but an array whose elements are pointers to structure How to declare array of pointer to structure? Below is an example declaration for array of pointer to structure. struct student *arr[10]; Here, arr is an array 10 of pointer to structure student. Dynamic memory allocation: Below is the procedure to perform dynamic memory allocation for the structure pointers in an array. struct student { int age; char name[32]; }; fun() { int i = 0; struct student *arr[10]; for (i = 0; i < 10; i++) { /* dynamic memory allocation for 5 structure objects */ arr[i] = (struct student *)malloc(sizeof(struct student) * 5); } } Write a c program to pass an array of structure pointers to another function   #include <stdio.h>   #include <stdlib.h>   #include <string.h>   struct student {         int age, rollno;         char name[32];   };   /* printing details of stude...
Post a Comment
Read more

Nested function in C

What is nested function? If a function is defined inside another function, then it is called as nested function.  Nested function example in C: Consider the following example, int add(int a, int b) {        void print(int res) {          printf("Result is %d, res);       }       print(a+b);       return 0; } Here, print() is a nested function.  Because, it is defined inside another function named add() . Example C program using nested functions: #include <stdio.h> void add(int a, int b) { void print(int res) { // nested function printf("Result is %d\n", res); return; } print(a + b); // passing sum of a and b as parameter return; } int main() { add(10, 20); return 0; }   Output:   jp@jp-VirtualBox:~/$ ./a.out   Result is 30 Previous Next
Post a Comment
Read more

Difference between asterisk and ampersand operators in c

Address Operator (& - Ampersand): Returns address of the given variable.  Consider the following example, int *ptr, var = 10; ptr = &var; ptr = &var sets the address of the variable var to pointer ptr.  & is also called as reference operator. Let us try to understand the purpose of reference operator using the following example program.   #include <stdio.h>   int main() {         int var = 10, *ptr;         /* assigning address of variable var to pointer ptr */         ptr = &var;         /* printing the address of the variable var */         printf("Address of var is 0x%x\n", &var);         /* printing the value of pointer ptr */         printf("Value of ptr is 0x%x\n", ptr);         return 0;   }   Output:   jp@jp-VirtualBox:~/$ ./a.out   Address of var is 0x...
Post a Comment
Read more