When expressions are constructed using operands of different but compatible types, type
conversions are performed in order to determine the type of the resulting expression. The D
rules for type conversions are the same as the arithmetic conversion rules for integers in
ANSI C. These rules are sometimes referred to as the *usual arithmetic
conversions*.

A simple way to describe the conversion rules is as follows: each integer type is
ranked in the order `char`

, `short`

,
`int`

, `long`

, `long long`

, with the
corresponding unsigned types assigned a rank above its signed equivalent but below the next
integer type. When you construct an expression using two integer operands such as ```
x
+ y
```

and the operands are of different integer types, the operand type with the
highest rank is used as the result type.

If a conversion is required, the operand of lower rank is first
*promoted* to the type of higher rank.
Promotion does not actually change the value of the operand: it
simply extends the value to a larger container according to its
sign. If an unsigned operand is promoted, the unused high-order
bits of the resulting integer are filled with zeroes. If a
signed operand is promoted, the unused high-order bits are
filled by performing sign extension. If a signed type is
converted to an unsigned type, the signed type is first
sign-extended and then assigned the new unsigned type determined
by the conversion.

Integers and other types can also be explicitly
*cast* from one type to another. In D,
pointers and integers can be cast to any integer or pointer
types, but not to other types. Rules for casting and promoting
strings and character arrays are discussed in
Section 2.11, “Strings”. An integer or pointer cast
is formed using an expression such as:

y = (int)x;

where the destination type is enclosed in parentheses and used to prefix the source expression. Integers are cast to types of higher rank by performing promotion. Integers are cast to types of lower rank by zeroing the excess high-order bits of the integer.

Because D does not permit floating-point arithmetic, no floating-point operand conversion or casting is permitted and no rules for implicit floating-point conversion are defined.