arithmetic overflow because signed characters in C program

Question

We know that signed char can have values only from -128 to 127. but when we run the below program no overflow happens even though the l output exceeds the range of signed character.

#include <stdio.h>


int main()
{
    char i = 60;
    char j = 30;
    char k = 10;
    char l = (i*j)/k;
    printf("%d ", l);

    return 0;
}

the output of l is 180 which is out of range for char l, but i am not getting any error.

in other scenario if we take the same program but instead of arithmetic function if we simply put l=180 and try to print it then we get wrong answer.

#include <stdio.h>


int main()
{
    char i = 60;
    char j = 30;
    char k = 10;
    char l = 180;
    printf("%d ", l);

    return 0;
}

the answer that i get in 2nd case is -76. can anyone explain it why? even if i am virtually executing the same thing but i am getting different result.

EDIT:

This is the classic example that the intermediate computations are made in int and not char

so in 1st when i am doing computation it is taking all values in int and in the later part i am explicitly mentioning it as char.

Answer 1

The C language is actually unable to perform any form of calculations on char types. char is a small integer type, meaning that whenever it appears as part of an expression, it always gets implicitly promoted to int. This is called integer promotion or the integer promotion rules.

In addition, there is another implicit type conversion back to char, since you store the result, which is of type int, inside a char. This is called lvalue conversion: it converts the result of an expression to the type of the designated object.

char l = (i*j)/k;

is therefore completely equivalent to

char l = (char)( (int)i * (int)j / (int)k );

Since all arithmetic is carried out on type int, there are no overflows. The result 180 may or may not fit inside a char.

You should avoid using char for any form of arithmetic, because it has implementation-defined signedness. On one system it might be signed, -128 to 127, on another system it might be unsigned, 0 to 255. Use uint8_t instead, it is a better and safer type.

Answer 2

Are you sure you did and test what you described in the first snippet? If it is run, it overflows wraps around as expected.

It makes a big difference if you did

char l = (i*j)/k;
printf("%d ", l);

And if you did

printf("%d ", (i*j)/k);

As in the second case, the compiler would infer the usage of an int as the output, (the result could not fit inside a char without wrapping around obviously), and primarily because the intermediate computations are made in int and not char.

In addition, consider that the result actually fits inside an unsigned char, so check this case too.

In your case, I would start thinking cases of a problematic compiler too, but only after I am sure what the program executed should do.

Answer 3

This happens because intermediate calculations are with int, not with char. char may be signed or unsigned, but the specs themselves say char, signed char and unsigned char are 3 distinct types.

EDIT: Found out why this happens: Signed char overflows, which triggers undefined behavior. That's why you don't get a constant. Signed integral types (signed char, signed int, signed long) all trigger undefined behavior on overflow. Optimization is allowed to do anything, although it mostly consists on ignoring the existence of the overflow.