What happens when a char is assigned a value too large to fit in a byte?

Question

Let's say I have a char pointer:

    char * cp;
    int val2 = 2;
    cp = &val2;
    *cp = 1234;

What will happen since the value 1234 is too large to fit in 1 byte? Will it just overflow and cause incorrect values to be stored, or will it somehow store the correct value across several bytes?

Answer 1

In *cp = 1234;, *cp refers to just one byte, the first (lowest-addressed) byte of val2.

In an assignment, the value of the right-hand side is converted to the type of the left side. So, 1234 will be converted to char.

There are two complications here. One, in most C implementations, 1234 is too big to fit into a char. (The C standard allows a char to be larger than eight bits, but this is rare in modern computers.) Two, char may be signed or unsigned.

If char is unsigned, then the conversion is well defined: 1234 is reduced modulo one more than the largest value of char (usually 255, so the reduction is modulo 256). In the usual case, 1234 will be reduced to 210, and this will be stored in the byte referred to by *cp.

If char is signed and 1234 does not fit in a char, then the conversion is implementation-defined or an implementation-defined signal is raised. In many modern C implementations, the result of the conversion will be -46.

The byte that cp points to after cp = &val2; is the lowest-addressed byte of val2. It is not necessarily the least significant byte of val2. Some C implementations store integers with the least significant byte lowest in memory (little endian), and some C implementations store integers with the most significant byte lowest in memory (big endian). (There are even systems that do not store the bytes in order; they may be mixed up in memory.)

Most modern C implementations store integers in two’s complement form without padding, so, once you know whether the C implementation is big-endian or little-endian, you would know how changing one byte would affect the value of the int. However, the C standard still permits sign-and-magnitude or ones’ complement. It also permits padding bits in signed integers.

Finally, note that char is a special type which permits accessing parts of other objects in this way. If, for example, you used short instead of char, as in short *sp = &val2; *sp = 0;, it would be a violation of aliasing rules, and the behavior would be undefined.