Concepts:
Casting of variables and mathematical expressions

Text:
Some examples regarding the mathematical operations between variable (or constant) of different types, and about the casting operator, have been proposed in order to explain such arguments.

Examples have been explained with comments in the code.

Theory: Regarding casting and mathematical expressions
The C programming language makes it possible to have operands with different type in the same mathematical expression.

Before actually perform the computation, the two operands of an expression are converted to the type with higher rank.

The ranks of C types, in increasing rank order are the following:

1. _Bool
2. char
3. short or short int
4. unsigned short or unsigned short int
5. int
6. unsigned int
7. long or long int
8. unsigned long or unsigned long int
9. long long or long long int
10. unsigned long long or unsigned long long int
11. float
12. double
13. long double

As an example, the following operation:

3.5+4;

is an operation between a float and an integer value, as a consequence the integer value is converted in a float value (i.e., 4.000000) and the operation is actually performed between two float numbers obtaining as result the value 7.500000.

The same concept holds also in the case variables are involved in a mathematical expression. For example, the following code:

int a;
float result;
a=4;
result = (3.6+a)*2;

stores in the variable result the value 15.20000 because the first operation (3.6+a) is performed between float numbers, indeed an operand (i.e., 3.6) is a float value and the variable a, which is an integer variable, is converted in a float number to perform the operation. The result of the operation (3.6+a) is the float number 7.200000. Once again the number 2 is converted into a float because one operand (i.e., 7.200000) is a float. At the end the variable result will contain the value 15.200000.

The type of a variable involved in a mathematical operation can be explicitly modified with the casting operator. The syntax of the casting operator is a type between brackets and before the variable that must be converted.

For example:

float result;
int x=2, y=3;
result = ((float)x/y) * x;

the division between x/y without the casting operator will give 0 as result, because is a division between two integer variables. With the casting operator before the variable x (i.e., (float)x), the value contained in the variable x is transformed in a float value (2.000000), therefore the division that contains a float operand is performed between floats and the result is 0.666666. Once again the float value 0.666666 is multiplied by 2 obtaining as a result the value 1.333333 with is stored in the variable result.

The same operation but with the casting operator outside the brackets:

result = (float)(x/y) * x;

stores in the variable result the value 0.000000, because from the division x/y the value 0 is obtained, which is converted by the casting operator into a float value (0.000000), and in turn it is multiplied by 2, obtaining finally 0.000000.

Solution:

casting.c

/* Some examples about mathematical expressions and casting */
 
#include <stdio.h>
 
 
int main() {
 
  int x = 2;
  int y = 3;
  float z = 3;
 
  float result;
 
  /* Division between integer numbers, the result is the integer
     number 0, then converted in the float number 0.000000 for the
     assignment to the variable result */
  result = 2/3;
  printf("A: %f\n", result);
 
  /* Division between an integer and a float number, the integer
     number is converted in a float number, and the operation
     is perform between two floats. The result is 0.666667. */
  result = 2.0/3;
  printf("B: %f\n", result);
 
  /* The same as the last operation. The number 3. is considered
     a float number */
  result = 2/3.;
  printf("C: %f\n", result);
 
  /* Division between integer variable, the result is the integer
     number 0, then converted in the float number 0.000000 for then
     assignment */
  result = x/y;
  printf("D: %f\n", result);
 
  /* The casting operator (float) converts the content of the variable x
     in a float number. Since now the division is performed 
     between a float and an integer number, the integer
     number is converted in a float number, and the operation
     is perform between two floats. The result is 0.666667. */
  result = (float)x/y;
  printf("E: %f\n", result);
 
  /* As before, in a division between an integer and a float value,
     the integer value is converted in a float and the division is
     performed between two floats. */
  result = x/z;
  printf("F: %f\n", result);
 
  /* The division x/y is a division between integer numbers (result is 0),
     the value 0 is then converted in a float value (0.000000), and then it
     is multiplied by x (which is converted into a float number
     because the other operator (float)(x/y) is a float number).
     The final result is 0.000000 */
  result = (float)(x/y) * x;
  printf("G: %f\n", result);
 
  /* In this case, the content of the variable x inside brackets is 
     converted in a float number, for this reason the division is performed
     between float numbers, obtaining a float result. The 
     result of the division is multiplied with x and, once again, the operation
     is performed between float numbers because one operand is a float.
     The result is 1.333333. */
  result = ((float)x/y) * x;
  printf("H: %f\n", result);
 
  /* In this last case, the result of the operation between the outer brackets
     is 1.333333 as in the previous operation (H:). This number is then converted
     in a int value and then saved in the result variable that is of type float.
     As a consequence, the content of the variable result is 1.000000. */
 
  result = (int) ( ((float)x/y) * x );
  printf("I: %f\n", result);
 
 
  return 0;
}

Output:
The output of this program is:

A: 0.000000
B: 0.666667
C: 0.666667
D: 0.000000
E: 0.666667
F: 0.666667
G: 0.000000
H: 1.333333
I: 1.000000