Type Casting Of Pointers in C

We saw that pointer values may be assigned to pointers of same type. However, pointers may be type cast from one type to another type. In the following code lines, A is an int type variable, D is variable of type double, and ch is a variable of type char. Pa is declared as a pointer to int variables, Pd is declared as a pointer to double type variables, and Pc is declared as pointer to character type variables. Pa is assigned the value &A.

int A= 150, *Pa;
Pa = &A;
double D, *Pd;
char ch, *Pc,

The code Pd = Pa is illegal; however, we may type cast Pd to type int by the following code:

Pd = (int*)Pd;

After type casting, the following assignment becomes legal:

Pd = Pa;

Similarly, Pc may be type cast to type int and assigned the value Pa.

(int*)Pc = pa;

After the execution of the above code all the three pointers, i.e., Pa, Pd, and Pc, point to the value 150.

Note the difference between the type casting of a variable and type casting of a pointer. Taking the above declarations of A, D, ch of the type int, double, and char, respectively. For type casting of D into type int, the code is

D = (int)D;

While for type casting a double pointer Pd into pointer for int the code is as below.

Pd = (int*)pd;

Illustrates assigning of pointers and addresses

#include<stdio.h> 
void main ()  { 
 int n = 10, m= 20, * pn, * pm; 
 char ch = 'H' , *pch; 
 double x = 3.650 ; 
 float y=5.5, *py = &y; 
 double * px = &x; 
 clrscr(); 
 pn = &n; //pointer pn is assigned value &n. 
 pm = &m; //Pointer is assigned value &m 
 pch = &ch; // pointer pch is assigned value &ch. 
 printf("n = %d\t x = %.31f\t ch = %c\n", n, x, ch); 
 printf("*pn= %d,\t*pm = %d,\t *pch = %c\n",*pn, *pm,*pch); 
 printf("*px = %.3lf\n", *px); 
 pm= pn ; // pm is assigned the value of pn. Both of same type. 
 printf("*pm= %d\n", *pm); 
 (char*)pn = pch; 
 // pn is type cast to char* and pch is assigned to it. 
 printf("*pn= %c\n", *pn); 
 (float*)px = py; 
 printf("*px = %.3f\n", *(float*)px); 
 (char*) px = pch; 
 printf("*px = %c\n", *px); 
 (float*) pch = py; 
 printf("*pch= %.3f\n", *(float*)pch); 
} 

The output is as given below.

The variables n and m are of type int, while x, ch, and y are of type double, char, and float, respectively. The pointers pn and pm are of type int and are initialized with values &n and &m, respectively, while px, py, and pch are initialized by values &x, &y, and &ch, respectively. The dereferencing of the pointers gives the values of the respective variables. See lines 2 and 3 of output.

In the program pn is assigned to pm. This is valid because both are of type int. Now, value of *pm is equal to value of n because pm now points to value of n. See the fourth line of output. Next, pn is type cast to type char* and assigned the value pch. The dereferencing of pn now gives character ‘H’ which is the value of ch. Next px is type cast to type float from type double and is assigned the value py. The dereferencing of px may not display the value of y unless it is cast in printf () also. So, to get the value of y we write * (float*) px in the output statement You may get a similar problem when pch is type cast to type float. See the last line of the program. The inference is that students should be extremely careful while type casting pointers.