When expressions are constructed by using operands of different
but compatible types, type conversions are performed 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 higher than 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 with the lower rank is
first *promoted* to the type of the 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 that is
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, “DTrace Support for Strings”.

An integer or pointer cast is formed using an expression such as the following:

y = (int)x;

In this example, 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.