A number of operators can, depending on the types of their operands, cause an implicit conversion of some operands from one type to another. The following discussion explains the results you can expect from these conversions. The conversions demanded by most operators are summarized in “Arithmetic Conversions”. When necessary, a discussion of the individual operators supplements the summary.

You can use a character or a short integer wherever you can use an integer.
Characters are `unsigned` by default. In all cases, the value
is converted to an integer. Conversion of a shorter integer to a longer integer
preserves the sign. Traditional C uses “`unsigned`
preserving integer promotion” ` (``unsigned short
` to `unsigned int`), while ANSI C uses “value
preserving integer promotion” (`unsigned short`
to `int`).

A longer integer is truncated on the left when converted to a shorter
integer or to a `char`.
Excess bits are discarded.

Historically in C, expressions containing floating point operands (either `
float` or `double`) were calculated
using double precision. This is also true of calculations in traditional C,
unless you have specified the compiler option `-float`. With
the `-float` option, calculations involving floating point
operands and no `double` or `long double`
operands take place in single precision. The `-float` option
has no effect on argument promotion rules at function calls or on function
prototypes.

ANSI C performs calculations involving floating point in the same precision
as if `-float` had been specified in traditional C, except
when floating point constants are involved.

In traditional C, specifying the `-float
` option coerces floating point constants into type float if all
the other subexpressions are of type float. This is not the case in ANSI C. ANSI
C considers all floating point constants to be implicitly double precision,
and operations involving such constants therefore take place in double precision.
To force single precision arithmetic in ANSI C, use the `f`
or `F` suffix on floating point constants. To force long
double precision on constants, use the `l` or `L
` suffix. For example, `3.14l` is long double precision, `
3.14` is double precision, and `3.14f` is single
precision in ANSI C.

For a complete discussion with examples, see “Type Promotion and Floating Point Constants” in Chapter 2.

Conversions between floating and integral values are machine-dependent.
SGI uses IEEE floating point, in which the default rounding mode
is to nearest, or in case of a tie, to even. Floating point rounding modes
can be controlled using the facilities of `fpc`. Floating
point exception conditions are discussed in the introductory paragraph of Chapter 6, “Expressions and Operators”.

When a floating value is converted to an integral value, the rounded value is preserved as long as it does not overflow. When an integral value is converted to a floating value, the value is preserved unless a value of more than six significant digits is being converted to single precision, or fifteen significant digits is being converted to double precision.

An expression of integral type can be added to or subtracted from an object pointer. In such a case, the integer expression is converted as specified in the discussion of the addition operator in “Additive Operators” in Chapter 6. Two pointers to objects of the same type can be subtracted. In this case, the result is converted to an integer as specified in the discussion of the subtraction operator, in “Additive Operators” in Chapter 6.

When an `unsigned` integer is converted
to a longer `unsigned` or `signed` integer,
the value of the result is preserved. Thus, the conversion amounts to padding
with zeros on the left.

When an `unsigned` integer is converted to a shorter `
signed` or `unsigned` integer, the value is truncated
on the left. If the result is `signed`, this truncation may
produce a negative value.

Many types of operations in C require two operands to be converted to
a common type. Two sets of conversion rules are applied to accomplish this
conversion. The first, referred to as the integral promotions, defines how
integral types are promoted to one of several integral types that are at least
as large as `int`. The second, called the usual arithmetic
conversions, derives a common type in which the operation is performed.

ANSI C and traditional C follow different sets of these rules.

The difference between the ANSI C and traditional
versions of the conversion rules is that the traditional C rules emphasize
preservation of the (`un`)`signed`ness of
a quantity, while ANSI C rules emphasize preservation of its value.

In traditional C, operands of types `char`, `
unsigned char`, and `unsigned short` are
converted to `unsigned int`. Operands of types `
signed char` and `short` are converted to `
int`.

ANSI C converts all `char` and `short`
operands, whether `signed` or `unsigned`,
to `int`. Only operands of type `unsigned int
`, `unsigned long`, and `unsigned long long
` may remain `unsigned`.

Besides differing in emphasis on signedness and value preservation, the usual arithmetic conversion rules of ANSI C and traditional C also differ in the precision of the chosen floating point type.

The following subsections describe two sets of conversion rules, one for traditional C, and the other for ANSI C. Each set is ordered in decreasing precedence. In any particular case, the rule that applies is the first whose conditions are met.

Each rule specifies a type, referred to as the result type. Once a rule has been chosen, each operand is converted to the result type, the operation is performed in that type, and the result is of that type.

The traditional C conversion rules are as follows:

If any operand is of type

`double`, the result type is`double`.If any operand is of type

`float`, the result type is`float`if you have specified the [-float ] switch. Otherwise, the result type is`double`.The integral promotions are performed on each operand as follows:

If one of the operands is of type:

The result is of type:

`unsigned long long``unsigned long long``long long``long long``unsigned long``unsigned long``long``long``unsigned int``unsigned int``otherwise``int`

The ANSI C rules are as follows:

If any operand is of type

`long double`, the result type is`long double`.If any operand is of type

`double`, the result type is`double`.If any operand is of type

`float`, the result type is`float`.The integral promotions are performed on each operand as follows:

If one of the operands is of type:

The result is of type:

`unsigned long long``unsigned long long``long long``long long``unsigned long``unsigned long``long``long``unsigned int``unsigned int``otherwise``int`

The following three sections discuss conversion of lvalues, function designators, void objects, and pointers.

Except as noted, if an lvalue that has type “array of <type>” appears as an operand, it is converted to an expression of the type “pointer to <type>.” The resultant pointer points to the initial element of the array. In this case, the resultant pointer ceases to be an lvalue. (For a discussion of lvalues, see “Objects and lvalues” in Chapter 4.)

A function designator is an expression that has function type. Except as noted, a function designator appearing as an operand is converted to an expression of type “pointer to function.”

The (nonexistent) value of a `
void` object cannot be used in any way, and neither explicit nor
implicit conversion can be applied. Because a `void` expression
denotes a nonexistent value, such an expression can be used only as an expression
statement (see “Expression Statement” in Chapter 8), or as the left operand
of a comma expression (see “Comma Operator” in Chapter 6).

An expression can be converted to type `void` by use
of a cast. For example, this makes explicit the discarding of the value of
a function call used as an expression statement.

A pointer to `void`
can be converted to a pointer to any object type and back without change in
the underlying value.

The NULL pointer constant can be specified either as the integral value
zero, or the value zero cast to a pointer to `void`. If a NULL
pointer constant is assigned or compared to a pointer to any type, it is appropriately
converted.