C Programming - Bitwise Operators - Discussion

#include<stdio.h>

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

In this case, also typecast operation is performed but final data is stored in 8 bit so the output is 0.

i=0x80 means( 0000 0000 1000 0000).

i<<1means (0000 0001 0000 0000)= 256.

How 0x80 is converted into binary?

// 1

#include<stdio.h>

int main()
{
unsigned char i = 0x80;
printf("%d\n", i<<1);
return 0;
}
Here output 256.

// 2
#include<stdio.h>

int main()
{
unsigned char i = 0x80;
i=i<<1;
printf("%d\n", i);
return 0;
}
Here output 0.

* The diff is assignment of variable i.

0*80 means 0000 0000 1000 0000.

Then, one time left shift(i<<1):0000 0001 0000 0000
According to position 1 is at 8th position, then to convert binary to decimal, 2^8=256.

It's pretty simple.

Step1 ) it's 8 0, binary is 1000 0000 <= 128.
8 0
Step2) char is converted to integer (It becomes int first, then the shift happens).
Step 3) Any type smaller than int (like char, short) is automatically promoted to int before arithmetic operations.
Step 4) if 1000 000 << 1.
Step 5) it becomes 0001 0000 0000.
Step 6) which is 256.

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.

if char i=0,if we use %c than it should print 0 on stdout.

But if we use %d it should print the equal ASCII value of that char.if it is 0 than 48 should print.memory will take on datatype but on formatspecifier provided.any way char should take 1byte to store,for signed char the range from -128 to +127.1 bit used for sign representation. For unsign char no loss of bit ranges from 0 to 255.256 not valid in char type.
in microcontroller suppouse 8051 all registers 8-bit othar dptr(16bit) if accumulator a regester value exceeds 8 bit then it will generate the carry.

if were a larger type (e.g., int), 0x80 << 1 would be 256 (binary 100000000).
But the unsigned char is 8-bit, so the overflow bit is discarded, leaving 00000000 (0).
So, I think answer is 0

int 0x86 means it is in hexadecimal So the decimal equivalent of 86 is 128. Left shift of 128 is 256 because left shift by 1 of a number is equivalent to multiplying it with 2.