In this tutorial we will learn about type conversion in C programming language.

In C we can have expressions consisting of constants and variables of different data types.

There are two type of conversions in C.

- Implicit type conversion
- Explicit type conversion

C performs automatic conversions of type in order to evaluate the expression. This is called implicit type conversion.

For example, if we have an integer data type value and a double data type value in an expression then C will automatically convert integer type value to double in order to evaluate the expression.

Following are the rules for the implicit type conversion in C.

First, all `char`

and `short`

are converted to `int`

data type.

Then,

- If any of the operand in the expression is
`long double`

then others will be converted to`long double`

and we will get the result in`long double`

. - Else, if any of the operand is
`double`

then other will be converted into`double`

and the result will be in`double`

. - Else, if any of the operand is
`float`

then other will be converted into`float`

and the result will be in`float`

. - Else, if any of the operand is
`unsigned long int`

then others will be converted into`unsigned long int`

and we will get the result in`unsigned long int`

. - Else, if any of the operand is
`long int`

and another is in`unsigned int`

then,- If
`unsigned int`

can be converted to`long int`

then it will be converted into`long int`

and the result will be in`long int`

. - Else, both will be converted into
`unsigned long int`

and the result will be in`unsigned long int`

.

- If
- Else, if any of the operand is
`long int`

then other will be converted to`long int`

and we will get the result in`long int`

. - Else, if any of the operand is
`unsigned int`

then other will be converted into`unsigned int`

and the result will be in`unsigned int`

.

Remember the following hierarchy ladder of implicit type conversion.

If we downgrade from a higher data type to a lower data type then it causes lose of bits.

For example: Moving from `double`

to `float`

causes rounding of digits.

Downgrading from `float`

to `int`

causes truncation of the fractional part.

In explicit type conversion we decide what type we want to convert the expression.

Syntax of explicit type conversion is:

`(type) expression`

Where, **type** is any of the type we want to convert the **expression** into.

In the following example we are converting floating point numbers into integer.

```
#include <stdio.h>
int main(void)
{
//variables
float
x = 24.5,
y = 7.2;
//converting float to int
int result = (int) x / (int) y;
//output
printf("Result = %d\n", result);
printf("End of code\n");
return 0;
}
```

Output

```
Result = 3
End of code
```

In the above code `(int) x`

converts the value 24.5 into 24 and `(int) y`

converts the value 7.2 into 7 so, we get 24/7 i.e., 3 as result because `result`

is of type int and hence the decimal part is truncated.

Recently Updated

- Product of Sums reduction using Karnaugh Map Boolean Algebra
- Sum of Products reduction using Karnaugh Map Boolean Algebra
- Karnaugh Map Boolean Algebra
- Sum of Products and Product of Sums Boolean Algebra
- Minterm and Maxterm Boolean Algebra
- Basic laws and properties of Boolean Algebra Boolean Algebra
- Propositional Logic Syllogism Boolean Algebra
- Propositional Logic Equivalence Laws Boolean Algebra
- Propositional Logic Important Terms Boolean Algebra
- Propositional Logic Truth Table Boolean Algebra