Arithmetic Conversions
 Important This document may not represent best practices for current development, links to downloads and other resources may no longer be valid. Current recommended version can be found here. ArchiveDisclaimer

# Arithmetic Conversions

Visual Studio .NET 2003

Many binary operators (discussed in Expressions with Binary Operators) cause conversions of operands and yield results the same way. The way these operators cause conversions is called "usual arithmetic conversions." Arithmetic conversions of operands of different types are performed as shown in the following table:

Conditions for Type Conversion

Conditions Met Conversion
Either operand is of type long double. Other operand is converted to type long double.
Preceding condition not met and either operand is of type double. Other operand is converted to type double.
Preceding conditions not met and either operand is of type float. Other operand is converted to type float.
Preceding conditions not met (none of the operands are of floating types). Integral promotions are performed on the operands as follows:
• If either operand is of type unsigned long, the other operand is converted to type unsigned long.
• If preceding condition not met, and if either operand is of type long and the other of type unsigned int, both operands are converted to type unsigned long.
• If the preceding two conditions are not met, and if either operand is of type long, the other operand is converted to type long.
• If the preceding three conditions are not met, and if either operand is of type unsigned int, the other operand is converted to type unsigned int.
• If none of the preceding conditions are met, both operands are converted to type int.

The following code illustrates the conversion rules described in the table:

```float   fVal;
double  dVal;
int   iVal;
unsigned long ulVal;

dVal = iVal * ulVal; // iVal converted to unsigned long;
// result of multiplication converted to double.

dVal = ulVal + fVal; // ulVal converted to float;
// result of addition converted to double.
```

The first statement in the preceding example shows multiplication of two integral types, `iVal` and `ulVal`. The condition met is that neither operand is of floating type and one operand is of type unsigned int. Therefore, the other operand, `iVal`, is converted to type unsigned int. The result is assigned to `dVal`. The condition met is that one operand is of type double; therefore, the unsigned int result of the multiplication is converted to type double.

The second statement in the preceding example shows addition of a float and an integral type, `fVal` and `ulVal`. The `ulVal` variable is converted to type float (third condition in the table). The result of the addition is converted to type double (second condition in the table) and assigned to `dVal`.