how 256 stored in char variable and unsigned char

Question

Up to 255, I can understand how the integers are stored in char and unsigned char ;

#include<stdio.h>
int main()
{
        unsigned char a = 256;
        printf("%d\n",a);
        return(0);
}

In the code above I have an output of 0 for unsigned char as well as char.

For 256 I think this is the way the integer stored in the code (this is just a guess):

First 256 converted to binary representation which is 100000000 (totally 9 bits).

Then they remove the remove the leftmost bit (the bit which is set) because the char datatype only have 8 bits of memory.

So its storing in the memory as 00000000 , that's why its printing 0 as output.

Is the guess correct or any other explanation is there?

Your explanation is more or less correct in this instance, but technically it's [Undefined Behaviour](https://en.wikipedia.org/wiki/Undefined_behavior). — Paul R, Feb 03 '14 at 14:52
What are you asking? 256 is not a valid char (it overflows). — Elliott Frisch, Feb 03 '14 at 14:52
I believe the question is asking if overflow is the reason for the observed behavior. — jonhopkins, Feb 03 '14 at 14:53
I think that it is not undefined behavior, C standard does specify what happens in this case. The variable ends up with number modulo (2^n), where n is the size in bits of the variable type. In this case, modulo 256. Some discussion in http://stackoverflow.com/questions/5881895/truncating-an-int-to-char-is-it-defined — epx, Feb 03 '14 at 14:59

Mike Seymour · Accepted Answer · 2015-02-11T15:43:19.087

16

Your guess is correct. Conversion to an unsigned type uses modular arithmetic: if the value is out of range (either too large, or negative) then it is reduced modulo 2^N, where N is the number of bits in the target type. So, if (as is often the case) char has 8 bits, the value is reduced modulo 256, so that 256 becomes zero.

Note that there is no such rule for conversion to a signed type - out-of-range values give implementation-defined results. Also note that char is not specified to have exactly 8 bits, and can be larger on less mainstream platforms.

edited Feb 11 '15 at 15:43

answered Feb 03 '14 at 14:54

Mike Seymour

249,747
28
448
644

2

Can be larger, but I think minimum size is 8 bits. – David Ranieri Feb 03 '14 at 15:00
2

Yup, ISO C states that `UCHAR_MAX` is _at least_ 255. Logically that means 8 bits. – MSalters Feb 03 '14 at 15:03
@AlterMann: I think you're right. (The type spec. just says it must be large enough to represent the execution character set, but the C library spec. requires a minimum of 255 for `UCHAR_MAX`). – Mike Seymour Feb 03 '14 at 15:05
For signed integers, out-of-range conversion is implementation defined, not undefined ([conv.integral]/p3). Overflow during arithmetic is undefined. – T.C. Feb 11 '15 at 11:49

score 1 · Answer 2 · answered Feb 03 '14 at 14:55

On your platform (as well as on any other "normal" platform) unsigned char is 8 bit wide, so it can hold numbers from 0 to 255.

Trying to assign 256 (which is an int literal) to it results in an unsigned integer overflow, that is defined by the standard to result in "wraparound". The result of u = n where u is an unsigned integral type and n is an unsigned integer outside its range is u = n % (max_value_of_u +1).

This is just a convoluted way to say what you already said: the standard guarantees that in these cases the assignment is performed keeping only the bits that fit in the target variable. This norm is there since most platform already implement this at the assembly language level (unsigned integer overflow typically results in this behavior plus some kind of overflow flag set to 1).

Notice that all this do not hold for signed integers (as often plain char is): signed integer overflow is undefined behavior.

score 1 · Answer 3 · answered Feb 03 '14 at 14:56

yes, that's correct. 8 bits can hold 0 to 255 unsigned, or -128 to 127 signed. Above that and you've hit an overflow situation and bits will be lost.

Does the compiler give you warning on the above code? You might be able to increase the warning level and see something. It won't warn you if you assign a variable that can't be determined statically (before execution), but in this case it's pretty clear you're assigning something too large for the size of the variable.

how 256 stored in char variable and unsigned char

3 Answers3

Linked