# What is widening , truncation , promotion , and conversion between , the different C , arithmetic data types ?

The arithmetic data types in C , are the integer types , such as `int` or `unsigned long` , and the floating point types , such as ` float ` , or ` long double` .

## Conversion of the integer types

### What is widening ?

Widening only applies to the signed and unsigned integer types . It does not apply to other types , such as `float` or `double` .

Widening is not about converting from signed to unsigned , or from unsigned to signed , it is about expanding the signedness of an integer type , from a smaller type to a larger type , so from a smaller number of bits , to a larger one . The signedness of the integer type does not change .

For the signed type , widening is done by what is called : `sign extension` . If the value of the signed type is negative , it is extended by filling the new bits by the value `1` , if the value of the signed type is nonnegative , than it is extended by filling the newly allocated bits , with `0` . For the unsigned type , the newly allocated bits are filled with `0` . ### What is truncation ?

Truncation happens only for the integer types , that have the same signedness , when passing from a larger integer type , to a smaller integer type , such as , when passing from `int` to `char` , or from `unsigned int` to `unsigned char`.

Be it is signed or unsigned , the larger type is made to fit the smaller type , by discarding the bits , of the larger type , that lies outside of the width of the smaller type , keeping only the lower order bits . Truncation as described , which is keeping only a limited number of bits , doesn’t happen when converting from a floating point type , to an integer type , or between floating point types .
When converting from a floating type , to an integer type , the fractional part is discarded , the floating type bits are not made to fit the integer type width , but the floating type is transformed from a floating point representation , to an integer representation .

### The integer conversion procedure

Conversion of the integer types , consists of either performing widening or truncation first , and later reinterpreting the bits .
So first truncation or widening is performed . Truncation or widening does not change the signedness of the type , the type is only made to fit , a larger or narrower width , of the same signedness .
After having performed widening or truncation , the gotten bits in the target width , are only reinterpreted , as belonging to a new integer type , the target type .

The only exception to this rule , is when converting to the `_Bool` type , any nonzero value is converted to `1` , and any zero value , is converted to `0` .

Having explained , how conversion happens for the integer types , let us explain the concept of integer `rank` , before explaining when conversion to another integer type , takes place .

### What is a rank ?

Each integer type in C has a rank .

`unsigned` , and `signed` integer types of the same type , disregarding the signedness , have the same rank . For example `int` , and ` unsigned int` , have the same rank .

The order of the ranks of the integer types is , as follow :

```_Bool < signed char < short < int < long < long long
```

The rank of any standard integer type , outlined above , is larger than the rank of any implementation defined , extended integer type , having the same width .

The char , and `signed char` integer types , have the same rank .

The rank of an enum type is equal to its assigned implementation , defined integer type .

### Integer promotion

Integer types , which have a rank smaller than `int` , each is promoted , to either the `int` type , if the `int ` type can represent all its possible values , or to the `unsigned int` type , in the other case .

Integer types having a rank smaller than `int` , are promoted when an operator expects , that one of its operand , to be of an arithmetic type . Arithmetic types in C , are the integer or floating point types . An example of such an operator , is the subtraction operator `-` , or the unary negation operator `-` .

Integer promotion , is not how the integer is converted to another type , it is when a integer is converted to another type , in this case it is because it has a lower rank than `int` .

```unsigned char x = 1;
signed char y = -x;
/*
x , is an unsigned char type ,
it has a rank lower than int .
The unary negation operator is
used , as such x must be promoted .
An int on 32 bits systems , have a
typical width of 32 bits , as such
it can store all the possible values
of an unsigned char , which is limited
to only 8 bits . As such the target
promotion type is an int .
Now that the target type is decided ,
which is an int , it has a larger
width than an unsigned char , as
such widening must be performed .
Widening does not change  signedness ,
so the unsigned char is widened to an
unsigned int , by using zero fill .
The resulting value is 1 ,  and has a bit
representation of :
00000000000000000000000000000001
The resulting bits , are interpreted as if ,
as being of the type signed int , and the
negation operator is applied .
The result of the negation operator is -1 ,
which , has a bit representation of :
11111111111111111111111111111111
The value is to be stored in a signed
char type , both int and signed char ,
have the same signedness , as such
truncation is applied .
The width of a signed char type is
8 bits , as such the leading 24 bits
are discarded , and the result is :
11111111 , which is equal to -1 . */
```

### Function call or return value

When making a function call , and an argument is of an integer type , different from the target parameter integer type , type conversion occurs .

The argument is converted to the parameter type , by first truncation , or widening , to the same width , and later on reinterpreting the bits as of the target parameter type .

```#include<stdio.h>

void trivialFunction( unsigned int val){
if( val == 4294967295){
printf( "%u is equal to 4294967295\n" , val);
}
else{
printf( "%u is different from 4294967295\n" , val);}}

int main( void){
signed char x	= -1 ;
trivialFunction( x);
unsigned char y = x ;
trivialFunction( y);}

/* Output
4294967295 is equal to 4294967295
255 is different from 4294967295
*/

/*
In the first call to trivialFunction ,
the passed argument is of type signed
char . trivialFunction expects its
argument , to be of the type unsigned
int , as such the argument must be
converted .
First widening to the same width of
unsigned int takes place .
x is a signed char , as such it is
widened to a signed int , by sign
extension . The value of x is -1 ,
and it has a bit representation of
11111111 . The resulting value is -1 ,
and it has a bit representation of
11111111111111111111111111111111 .
This bit pattern , is next reinterpreted
as an unsigned int , so
11111111111111111111111111111111 ,
as an unsigned int , has a value of
4294967295 . This is why trivialFunction
prints : 4294967295 is equal to 4294967295

The variable y , has a type of unsigned
char . It is assigned the value of x ,
which is a signed char .
Both x , and y have the same width , as such
no widening occurs , only the bits of x ,
are reinterpreted as being unsigned .
The bits of x , has a value of -1 , which is
11111111 , when reinterpreted as unsigned ,
this yield the value of 255 .
Next trivialFunction is called with y ,
as a parameter .
Widening occurs  , because y is an unsigned
char , and the function parameter is an
unsigned int . It is done by using
zero fill .
Hence the value of 1 which has a bit
representation of 11111111 , is widened
to the value 255 which has a bit
representation of :
00000000000000000000000011111111
The function prints :
255 is different from 4294967295
*/
```

When the return value of a function is different from its return type , the return value is converted to the function’s return type .

### Assignment and initialization

When performing assignment or initialization to an integer variable , using the `=` operator , and the expression to be assigned , is of a different integer type , integer conversion takes place .

```unsigned char x = 1 ;
/*
1 is an integral literal ,  it is
of the type int .
The type int has a typical width
of 32 bits , while an unsigned
char has a typical width
of 8 bits .
The bits of the int type
00000000000000000000000000000001
are reinterpreted as  being the
bits of an unsigned int type .
The result is :
00000000000000000000000000000001
The unsigned int value is truncated to
8 bits , and the value gotten is
00000001 , which is assigned to
the unsigned char x .*/
```

For further information , about the type of integer literals , you can check this article .

### Arithmetic operators

When one of the following operators , is being used , an integer conversion will occur .

```* / % + -
/*
Multiplication , division ,
subtraction  .*/

< <= > >= == !=
/*
Relational less , less or equal ,
larger , larger or equal ,
equal , not equal .*/

& ^ |
/*
Bitwise and , xor , or .*/

?:
/*
The Ternary operator expression ,
must return a value of a specific
type , the second and third operand ,
are converted to a same type . */

+=  -=  *=  /=  %=  &=   ^=  |=
/* operate and assign operators  */
```

In the case of these operators , a common type for the operands and the result must be determined . This is done as specified by the following table .

Unsigned Signed Rank Operands and Result type
uT sT uT >= sT uT
uT sT uT < sT sT , if sT is capable of holding , all the possible values of : uT .

The unsigned type of sT , if sT is not capable of holding all the possible values of : uT .
uT , means an unsigned type , such as : `unsigned int`
sT , means a signed type , such as :`int`
The result of relational operators such as < , is always 0 for true , and 1 for false , and it is always of the type int .
```int si = -1 ;
unsigned int ui = 0 ;

ui = ui + si ;
/*
int , and unsigned int , have the same
rank , one is signed , and the other
is unsigned , as such both operands ,
must be converted to the unsigned int
type , and the result of the operation ,
is of an the unsigned int type .
ui is unsigned , so no conversion is
necessary .
To convert si , to the unsigned int type ,
and since both si and ui have the same
width , the bits of si , which are
11111111111111111111111111111111 ,
are kept as is , they are only reinterpreted
as belonging to a signed type , so now
they have a value of 4294967295 .
The addition is performed , and the result
of the addition operation , is as such :
4294967295 + 0 = 4294967295 , and is
of the type unsigned int .
ui is of type unsigned int , as such
no conversion is necessary , and the
result of 4294967295 is stored in ui .
*/

long long lli = -1 ;
ui = lli + ui ;
/*
lli is of the type long long ,
it has a higher rank than
unsigned int . long long
can hold all the values of
unsigned int , as such ,
both operands must be of
the type long long .
lli is of the type long long ,
so no conversion is necessary .
ui is an unsigned int , it has
a bit representation of
11111111111111111111111111111111
it is first extended to unsigned
long by using zero fill .
0000000000000000000000000000000011111111111111111111111111111111
After that , the gotten bits are
reinterpreted as being of type
long long . The gotten value , is
the same as the value of ui , which
is 4294967295 .
The addition is  performed between ,
the two long long integer types , and
the result is -1 + 4294967295 , which
is equal to 4294967294 , and is of
the type long long .
ui is of the type unsigned int , the result
which is of the type long long  must
be converted to unsigned int  .
It is first converted to unsigned long long ,
the bits pattern does not change ,  so it remains
0000000000000000000000000000000011111111111111111111111111111110 .
Now that is is of the type unsigned long long ,
it is truncated to the type of ui , which is
unsigned int , and it has the format :
11111111111111111111111111111110  ,
and a value of : 4294967294 .
*/

long int li  = -1 ;
li = li + ui ;
/*
ui is an unsigned int , whereas li
is a long int . A long int has
a higher rank than an unsigned
int . Assuming that on this machine ,
both long int and unsigned int have
a width of 32 bits , this means
that long int is not capable of
representing all the possible values
of the unsigned int type , as such
the operands , and the result
must be of the unsigned long type .
li bits are kept as is , and only
reinterpreted as being of the
type unsigned long , as such li
will have the value of 4294967295 .
ui is converted to unsigned long , by
widening. unsigned int , and unsigned long
have the same width , as such the bits
of ui remains the same ,
11111111111111111111111111111110 .
8589934589 . The result is of
the type unsigned long , it cannot
fit the width of the unsigned
long type , which has a max
value of 4294967295 , as such
overflow has occurred .
The modulo of the result , with
regards to 2 to the power of
the number of bits ,
of the unsigned long type is taken .
This is equal to
8589934589 % 4294967296 =
4294967293 , which is
11111111111111111111111111111101
The result must be stored in li ,
li is of the long type , the gotten
value is of the type unsigned long ,
the bits are kept as is , and the
result is only reinterpreted as being
a signed long , as such the value
of li is -3 .
*/
```

For information on overflow of the signed , and unsigned integer types , you can check this , and this article .

### Cast operator

`Explicit` conversion happens , when using the casting operator : `(Type) expression` . As an example , explicitly casting the `int` literal `1` , to the `long` type .

```(long) 1
```

When using the cast operator , this is called `explicit` casting , all other cases of conversion , are called `implicit` casting .

## Conversion of the floating point types

### Converting from one floating type , to another

Each floating point type , has a different range , and precision . As such , when passing from floating point types , with higher precision and range , to floating point types with smaller precision and range , a loss of precision , an underflow , or an overflow , can occur .

```double dbl = 16777217 ;
float fl = dbl ;
/*
Loss of precision , fl value is
16777216 .*/

dbl = 1.2e-50 ;
fl = dbl ;
/*
Underflow occurs , the behavior
is implementation defined ,
in this case , fl has a value
of 0 .*/

dbl = 3.4e100;
fl = dbl ;
/*
Overflow occurs , the behavior
is implementation defined ,
fl has a value
of positive infinity */
```

When passing from a floating point type , with a smaller range and precision , to a floating point type , with a higher range and precision , no precision loss , underflow , or overflow , occurs . The precision and range are preserved .

```float fl = 1.099511627776e12f;
double dbl = fl ;
/*
precision and range are
preserved , dbl has a
value of :
1.099511627776e12f ,
which is 2 to the
power 40 .*/
```

### Converting from a floating point type , to an integer type

The process of converting a floating point type , to an integer type , can be thought of , as if , the number is first converted to the decimal notation , then the fractional part is discarded , then it is represented in its signed or unsigned representation .

```double dbl = 1.3f;
unsigned char uc = (unsigned char) x ;
// uc is equal to 1

dbl  = -1.3f;
uc = dbl  ;
// uc is equal to 255
```

If the floating point number , is too large to be represented in an integer type , the behavior is not defined by the C standard , it is defined by the implementation .

```double dbl = 3.4E30 ;

unsigned long ul  = dbl ; //ul is equal to 0
unsigned int ui  = dbl ; //ui is equal to 0
unsigned char uc  = dbl ; //uc is equal to 0

long li  = dbl ; //li is equal to -9223372036854775808
int si  = dbl ; //si is equal to -2147483648
signed char sc  = dbl ; //sc is equal to 0
```

### Converting from an integer type , to a floating point type

When converting an integer type , to a floating point type , the integer value can always be represented , but there might be a loss of precision .

```int si = 16777216 ;
float fl = si ;  // fl is equal to 16777216

si = 16777217 ;
float fl = si ; // fl is equal to 16777216
```

### When does the conversion occurs ?

When a floating point type is involved , conversion occurs , when a function call is made , and the passed argument is of a different type than the function parameter , or when the return value of a function , is of different type , than its return type .

It also happens , when performing floating point variables , assignment and initialization . Finally , it occurs when using arithmetic operators , or when done explicitly , using explicit casting , such as ` (float) 1.0` .

### Rank of floating point types

The rank of a floating point type , is always higher than the rank of an integer type , so an integer type , is always converted to a floating point type .

As for the floating point types , they have the following ranks :

```float < double < long double
```

If an arithmetic operation , involves two floating point types of different ranks , the floating point type with the lower rank , is converted to the floating point type with the higher rank .

The type of the result of an operation involving a floating point type , is the same type , as the one determined by the ranking algorithm .

### Floating point types promotion

As with the integer type promotion , when performing arithmetic operations , a floating point type can be promoted , to a type with a higher precision and range .

This is not to be confused with how conversion happens , or in which rank , an arithmetic operation involving a floating point type , is to be performed , It is always performed using the higher operand rank .

The promotion rule , is defined in the macro `FLT_EVAL_METHOD` , defined in the header `float.h` .

If `FLT_EVAL_METHOD` is set to `0` , then arithmetic operations are done in the type of the widest operand , so if both operands are `float` , the arithmetic operation is done using the `float` type , so no promotion occurs .

If `FLT_EVAL_METHOD` is set to `1` , then arithmetic operations are performed , by promoting the operands to `long double` , if any operand is of the `long double` type , otherwise operands are promoted to the `double` type , even if both operands are of the `float` type .

If `FLT_EVAL_METHOD` is set to `2` , then arithmetic operations are performed , by promoting the operands , to the `long double` type .

If `FLT_EVAL_METHOD` is set to `-1` , then the behavior is not defined .