In this article, we explain what happens when we attempt to assign a float value to a double variable and vice versa. We also discuss how expressions containing different numeric types (int and double, say) are evaluated in C.

- slide 1 of 3
### Assignment between double and float

As expected, you can store a

**float**value in a**float**variable and a**double**value in a**double**variable. Since**float**is smaller than**double**, C allows you to store a**float**value in a**double**variable without any problems. However, if you assign a**double**to a**float**, some precision may be lost. Consider the following:double d = 987.654321;

float x = d;

printf("%f \n", x);

Since a

**float**variable allows at most 7 digits of precision, we should expect that the value of**d**may not be assigned precisely to**x**. Indeed, when run using one compiler, the value 987.654297 was printed for**x**. When**d**was changed to 987654321.12345, the value printed was 987654336.000000. In both cases, about 6 or 7 digits of precision were retained.As an exercise, see what values would be printed using your compiler.

- slide 2 of 3
### Expressions with integer and floating-point values

It is quite common to use expressions involving both integer and floating-point values, for example,

**a / 3**where**a**is**float****n * 0.25**where**n**is**int**In C, the rule for such expressions is:

If either operand of an arithmetic operator is floating-point, the calculation is done in floating-point arithmetic. The calculation is done in

**double**unless*both*operands are**float**, in which case the calculation is done in**float**.In the first example above, the integer 3 is converted to

**float**and the calculation is done in**float**. In the second example,**n**is converted to**double**(since 0.25 is**double**) and the calculation is done in**double**.How do we get the exact value of an integer division, 19/5, say? We can force a double precision calculation by writing one or both constants as

**double**, thus: 19/5.0, 19.0/5 or 19.0/5.0. We can also use a cast, as in(double) 19 / 5

A cast allows us to force the conversion of one type to another. Here, the

**int**19 is cast to**double**, forcing 5 to be converted to**double**and a double precision division is performed.However, we must be careful with a construct like

(double) (19 / 5)

since it may not do what we think. This does NOT do a floating-point division. Since both constants are integer, the expression inside the brackets is evaluated as an integer division (which discards the remainder), giving 3;

*this*value is converted to**double**, giving 3.0. - slide 3 of 3

#### C Programming for Beginners

- C Programming For Beginners - Part 1
- C Programming For Beginners - Part 2
- C Programming for Beginners – Part 3
- C Programming for Beginners – Part 4
- C Programming For Beginners - Part 5
- C Programming For Beginners - Part 6
- C Programming For Beginners - Data Types
- C Programming For Beginners - Part 8
- C Programming For Beginners - Part 9
- C Programming For Beginners - Part 10
- C Programming For Beginners - Part 11
- C Programming For Beginners - Part 12
- C Programming For Beginners - Part 13
- C Programming For Beginners - Part 14
- C Programming For Beginners - Integer Data Types
- C Programming for Beginners - Part 16
- C Programming For Beginners - Integer Expressions, Operators and Precedence
- C Programming For Beginners - Part 18
- C Programming For Beginners - Printing Double and Float
- C Programming For Beginners - Mixing double, float and int