C Programming - Bitwise Operators - Discussion

Answer to Why everyone taking for char 2bytes?

we are not taking char as 2 bytes.
Let's picture the real scenario, the memory stored in the register of RAM.
for example, suppose 'i' is stored at 0x00 as shown in the below:

Address values
0x06 0000 0000
0x05 0000 0000
0x04 0000 0000
0x03 0000 0000
0x02 0000 0000
0x01 0000 0000
0x00 1000 0000 <----- i = 0x80;

now if we right shift the value of 'i', then MSB(most significant bit) will shifted to the next register* as shown below,

Address values
0x06 0000 0000
0x05 0000 0000
0x04 0000 0000
0x03 0000 0000
0x02 0000 0000
0x01 0000 0001
0x00 0000 0000 <----- i = 0x00;

It should show 0 if we read the value of 'i' as a character(%C) which is NULL(it will print NULL which is not a visible character like space).
But here we are reading the value of 'i' as integer(%d) so it will read the 4 bytes, which are,

0x03 0000 0000
0x02 0000 0000
0x01 0000 0001
0x00 0000 0000

In single line 00000000 00000000 00000001 00000000 <----- i = 0x100 = 256.

@Gopi Krishna, If we right shift the variable then MSB goes to next register's LSB, not the same one in C language.

One you are describing is the case of the microcontroller/processes @Kunal.

The answer should be zero. I checked it. Unsigned char takes only single byte.

#include<stdio.h>

int main()
{
unsigned char i = 0x80;
int a=i<<1;
unsigned long b=a;
unsigned char c=b;
printf("%d\n",c);
b=b>>1;
c=b;
printf("%d\n",c);
return 0;
}

Try this.

@Abhinav.

No, its not correct. 0X80 is a hexadecimal number, and for hexadecimal number you have to convert nibble by nibble.

For example:

0X80 --------> two nibbles 8 0.

1000 0000.

0X 75 -------> 7 5.

0111 0101.

Although, you are right if it were decimal number.

For example:

80 ----------> 01010000.

"0X" makes it hexadecimal.

Yes it is correct @Abhinav but when we consider that and tried to shift by 1 then answer goes wrong. Please anyone tell how I convert this hex number into binary.

Here x080 can be written as 0000 0000 0101 0000. Is it true?

Some are having doubt that why everyone having explanation assuming it is 2 byte?

First clear in you mind that we are not converting 1 byte of character into 2 byte.

Because if we do this then we have to write i = i<<2; but we are just printing a integer value using integer format specifier, but not changing the value of i.

After this program try this.

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

I am just want to show that value of i is not changing.

You will get the output as:

256 as value of integer after left shift and 128 as the value of the i.

So don't confuse between both.

#include<stdio.h>

int main()
{
char i=0x04;
char k=0x80;
printf("%d",i<<6);
printf("%d",k<<1);

return 0;
}

Output of first print statement is 256 while for other it is -256 how?

Size of char is 1 byte.
So it have 8 bits. The equivalent of 0*80 is 1000 0000.
If I do left shift then it is 0000 0001 so answer is 1.

This is my thinking. Can any one explain me correct?

Char should overflow to become zero instead its becoming 256.