Type Conversions
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 Chapter 6, 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.
