Conversion as if by assignment

In the assignment operator, the value of the right-hand operand is converted to the unqualified type of the left-hand operand.

In scalar initialization, the value of the initializer expression is converted to the unqualified type of the object being initialized

In a function-call expression, to a function that has a prototype, the value of each argument expression is converted to the type of the unqualified declared types of the corresponding parameter

In a return statement, the value of the operand of return is converted to an object having the return type of the function

Note that actual assignment, in addition to the conversion, also removes extra range and precision from floating-point types and prohibits overlaps; those characteristics do not apply to conversion as if by assignment.

4) Otherwise, both operands are integers. In that case, First of all, both operands undergo integer promotions (see below). Then

If the types after promotion are the same, that type is the common type

Otherwise, if both operands after promotion have the same signedness (both signed or both unsigned), the operand with the lesser conversion rank (see below) is implicitly converted to the type of the operand with the greater conversion rank

Otherwise, the signedness is different: If the operand with the unsigned type has conversion rank greater or equal than the rank of the type of the signed operand, then the operand with the signed type is implicitly converted to the unsigned type

Otherwise, the signedness is different and the signed operand's rank is greater than unsigned operand's rank. In this case, if the signed type can represent all values of the unsigned type, then the operand with the unsigned type is implicitly converted to the type of the signed operand.

Otherwise, both operands undergo implicit conversion to the unsigned type counterpart of the signed operand's type.

1.f + 20000001; // int is converted to float, giving 20000000.00
// addition and then rounding to float gives 20000000.00
(char)'a' + 1L; // First, char is promoted back to int.
// this is signed + signed case, different rank
// int is converted to long, the result is 98 signed long
2u - 10; // signed / unsigned, same rank
// 10 is converted to unsigned, unsigned math is modulo UINT_MAX+1
// for 32 bit ints, result is 4294967288 of type unsigned int (aka UINT_MAX-7)
0UL - 1LL; // signed/unsigned diff rank, rank of signed is greater.
// If sizeof(long) == sizeof(long long), signed cannot represent all unsigned
// this is the last case: both operands are converted to unsigned long long
// the result is 18446744073709551615 (ULLONG_MAX) of type unsigned long long

The result type is determined as follows:

if both operands are complex, the result type is complex

if both operands are imaginary, the result type is imaginary

if both operands are real, the result type is real

if the two floating-point operands have different type domains (complex vs. real, complex vs imaginary, or imaginary vs. real), the result type is complex

undergoes lvalue conversion: the type remains the same, but loses const/volatile/restrict-qualifiers and atomic properties, if any. The value remains the same, but loses its lvalue properties (the address may no longer be taken).

If the lvalue has incomplete type, the behavior is undefined.

If the lvalue designates an object of automatic storage duration whose address was never taken and if that object was uninitialized (not declared with an initializer and no assignment to it has been performed prior to use), the behavior is undefined.

This conversion models the memory load of the value of the object from its location.

Implicit conversion semantics

Implicit conversion, whether as if by assignment or a usual arithmetic conversion, consists of two stages:

1) value transformation (if applicable)

2) one of the conversions listed below (if it can produce the target type)

Compatible types

Conversion of a value of any type to any compatible type is always a no-op and does not change the representation.

uint8_t (*a)[10]; // if uint8_t is a typedef to unsigned char
unsigned char (*b)[] = a; // then these pointer types are compatible

Integer promotions

Integer promotion is the implicit conversion of a value of any integer type with rank less or equal to rank of int or of a bit field of type _Bool, int, signed int, unsigned int, to the value of type int or unsigned int.

If int can represent the entire range of values of the original type (or the range of values of the original bit field), the value is converted to type int. Otherwise the value is converted to unsigned int.

rank above is a property of every integer type and is defined as follows:

1) the ranks of all signed integer types are different and increase with their precision: rank of signed char < rank of short < rank of int < rank of long int < rank of long long int

2) the ranks of all signed integer types equal the ranks of the corresponding unsigned integer types

3) the rank of any standard integer type is greater than the rank of any extended integer type of the same size (that is, rank of __int64 < rank of long long int, but rank of long long < rank of __int128 due to the rule (1))

4) rank of char equals rank of signed char and rank of unsigned char

5) the rank of _Bool is less than the rank of any other standard integer type

6) the rank of any enumerated type equals the rank of its compatible integer type

7) ranking is transitive: if rank of T1 < rank of T2 and rank of T2 < rank of T3 then rank of T1 < rank of T3

8) any aspects of relative ranking of extended integer types not covered above are implementation defined

Note: integer promotions are applied only.

as part of usual arithmetic conversions (see above)

as part of default argument promotions (see above)

to the operand of the unary arithmetic operators + and -

to the operand of the unary bitwise operator ~

to both operands of the shift operators << and >>

Boolean conversion

A value of any scalar type can be implicitly converted to _Bool. The values that compare equal to zero are converted to ​0​, all other values are converted to 1.

Integer conversions

A value of any integer type can be implicitly converted to any other integer type. Except where covered by promotions and boolean conversions above, the rules are:

if the target type can represent the value, the value is unchanged

otherwise, if the target type is unsigned, the value 2b, where b is the number of bits in the target type, is repeatedly subtracted or added to the source value until the result fits in the target type. In other words, unsigned integers implement modulo arithmetic.

otherwise, if the target type is signed, the behavior is implementation-defined (which may include raising a signal)

A value of any integer type can be implicitly converted to any real floating type.

if the value can be represented exactly by the target type, it is unchanged

if the value can be represented, but cannot be represented exactly, the result is the nearest higher or the nearest lower value (in other words, rounding direction is implementation-defined), although if IEEE arithmetic is supported, rounding is to nearest. It is unspecified whether FE_INEXACT is raised in this case.

if the value cannot be represented, the behavior is undefined, although if IEEE arithmetic is supported, FE_INVALID is raised and the result value is unspecified.

The result of this conversion may have greater range and precision than its target type indicates (see FLT_EVAL_METHOD.

Real floating point conversions

A value of any real floating type can be implicitly converted to any other real floating type.

If the value can be represented by the target type exactly, it is unchanged

if the value can be represented, but cannot be represented exactly, the result is the nearest higher or the nearest lower value (in other words, rounding direction is implementation-defined), although if IEEE arithmetic is supported, rounding is to nearest

if the value cannot be represented, the behavior is undefined

The result of this conversion may have greater range and precision than its target type indicates (see FLT_EVAL_METHOD.

Real-imaginary conversions

A value of any imaginary type can be implicitly converted to any real type (integer or floating-point). The result is always a positive (or unsigned) zero, except when the target type is _Bool, in which case boolean conversion rules apply.

A value of any real type can be implicitly converted to any imaginary type. The result is always a positive imaginary zero.

Pointer conversions

A pointer to void can be implicitly converted to and from any pointer to object type with the following semantics:

If a pointer to object is converted to a pointer to void and back, its value compares equal to the original pointer.

No other guarantees are offered

int* p = malloc(10 * sizeof(int)); // malloc returns void*

A pointer to an unqualified type may be implicitly converted to the pointer to qualified version of that type (in other words, const, volatile, and restrict qualifiers can be added. The original pointer and the result compare equal.

int n;
const int* p = &n; // &n has type int*

Any integer constant expression with value ​0​ as well as integer pointer expression with value zero cast to the type void* can be implicitly converted to any pointer type (both pointer to object and pointer to function). The result is the null pointer value of its type, guaranteed to compare unequal to any non-null pointer value of that type. This integer or void* expression is known as null pointer constant and the standard library provides one definition of this constant as the macro NULL .

int* p = 0;
double* q = NULL;

Notes

Although signed integer overflow in any arithmetic operator is undefined behavior, overflowing a signed integer type in an integer conversion is merely unspecified behavior.

On the other hand, although unsigned integer overflow in any arithmetic operator (and in integer conversion) is a well-defined operation and follows the rules of modulo arithmetic, overflowing an unsigned integer in a floating-to-integer conversion is undefined behavior: the values of real floating type that can be converted to unsigned integer are the values from the open interval (-1; Unnn_MAX+1).

unsigned int n = -1.0; // undefined behavior

Conversions between pointers and integers (except from pointer to _Bool and from integer constant expression with the value zero to pointer), between pointers to objects (except where either to or from is a pointer to void) and conversions between pointers to functions (except when the functions have compatible types) are never implicit and require a cast operator.

There are no conversions (implicit or explicit) between pointers to functions and pointers to objects (including void*) or integers.