Type casting or type conversion refers to change of type of variables or pointers or user-defined objects from one type to another type. The need for type conversion arises in some operations involving two operands of different types, or even of same type. The example given below illustrates this concept.
int A = 5, B = 2, C;
float x = 5.5, y;
Now if we divide A by B, the result obtained is 2 because it is integer division and will give an integer value. The fractional part is cut off from the result. For obtaining the exact value, the type of either the numerator or the denominator has to be changed. Such a change is not done by the compiler and needs to be done explicitly in the program. The following operations have been demonstrated in Program.
C = x + A;
y = x+ A;
Program gives the above two values as C = 10 and y = 10.5, though both involve addition of same numbers. In the operation C = x + A; the type of x is converted to int, and in second case, the type of A is converted to float. These conversions are done automatically by the compiler and are called implicit conversions or implicit type casting.
Illustrates implicit type conversion.
void main ()
int A=5, B= 2 , C, M;
float x = 5.5, y;
C = A + x; // conversion of x from float to int
y = A + x; // conversion of A from int to float
M = A/B; // integer division results in M = 2
printf("C = %d \t y = %f\n", C, y );
printf("M = %d \n", M);
printf("x/B = %f \n", x/B);
The expected output is given below. The comments given in the program explain the output.
For implicit conversion, the different types are given a relative rank number as shown in the Figure.
The general principle is that if the ranks of the two operands are different, then determine the higher rank and convert the type of operand with lower rank to that of the higher rank so that both are of same rank.
In case of assignment, the type of the operand on the right side of equality symbol (=) is changed to match the rank of the operand on the left side of the equality symbol. The implicit type conversions are shown below in Program. The type of character 'A', in the program, is cast to float and similarly n is also converted to float to give the addition y = n + 'A' equal to 75.000000, whereas in case of x in the addition m = n + x, the x is converted to int value.
Illustrates implicit type conversion
void main ()
int n=10, m;
float x = 6.5, y;
double D = 5.5485;
m = n + x; // conversion from float to int
y = n + 'A'; // conversion from int to float
D = D + x;
printf (" m = %d,\t y = %f,\t D = %lf,\n", m, y, D);
Explicit Type Casting
In case of doubt about implicit type conversion, it is better to resort to explicit type conversion. This is carried out by putting the desired new type in parentheses followed by the expression that needs to be cast as illustrated below.
Thus, if int n is desired to be changed to type double, it may be carried out as (double) n;
Illustrates explicit type casting.
int k = 0 ,n = 0, m =0, S =70, P=0;
double x = 54.765, R, M;
char ch = 'Z';
n = (int)ch;
k = (int) x ;
printf("n = %d,\t k = %d \n", n, k );
ch = (char) S;
printf("ch = %c \t S = %d\n", ch, S );
R = 15.6/3.0;
P = (int) (15.6/3.0);
printf("R = %f,\t P = %d\n", R, P );
m = (10/3);
M = (double)10/3;
printf("M = %lf,\t m= %d\n", M,m );
The character ' Z ' has been cast into an integer n, so n = 90; the double number x is cast into integer k, so k = 54. These two conversions are displayed in the first line of the output. The int s = 7Ois cast into char, so value 'F' is obtained. This is shown in the second line of the output. The division 15.6/3.0 = 5.2, which gives the value of R. The whole division is converted into int, so we get P = 5. The integer division 10/3=3, which is the value of m. For M, the numerator is converted into a double number. So the correct value after division is 3.3333, giving the value of M.