What happens with bitwise shift for all 8 bits

Question

I have a small query in c, I am using the bitwise left shift on number 69 which is 01000101 in binary

01000101  << 8

and I get answer as 100010100000000

Shouldn't it be all 8 zeros i.e. 00000000 as we shift all the 8 bits to left and then pad with zeros.

if you say int i = 01000101 << 8; then i is 32 bits and the answer you see is expected. — bruceg, Feb 25 '16 at 00:19
All integer arithmetic (including shifts) is done in at least `int` precision — M.M, Feb 25 '16 at 00:23

Ian · Accepted Answer · 2016-02-25T06:26:41.303

8

It is because of the literal (default data type) for a number (int) is, in most of nowadays CPU, greater than 8-bit (typically 32-bit) and thus when you apply

69 << 8 //note 69 is int

It is actually applied like this

00000000 00000000 00000000 01000101 << 8

Thus you get the result

00000000 00000000 01000101 00000000

If you use, say, unsigned char specifically, then it won't happen:

unsigned char a = 69 << 8; //resulting in 0

This is because though 69 << 8 itself will still result in

01000101 00000000

But the above value will be casted to 8-bit unsigned char, resulting in:

00000000

edited Feb 25 '16 at 06:26

answered Feb 25 '16 at 00:20

Ian

30,182
19
69
107

So you means the answer is 00000000 00000000 01000101 00000000 – TechJ Feb 25 '16 at 00:21
1

@TechJ ah, yes. It depends on your CPU word length actually. But typically it is 32-bit. – Ian Feb 25 '16 at 00:23
Thanks Ian for your answer. – TechJ Feb 25 '16 at 00:26

ApproachingDarknessFish · Answer 2 · 2019-06-27T08:07:09.730

4

Bit shift operators act on entire objects, not individual bytes. If the object storing 69 is wider than 1 byte (int is typically 4 bytes for example), then the bits that are shifted outside of the first (lowest/rightmost) byte overflow and are "pushed into" the second byte. For example:

00000000 00000000 00000000 01000101 //The number 69, stored in a 32 bit object
00000000 00000000 01010000 00000000 //shifted left by 8

If you had stored the number in a 1-byte variable, such as a char, the result would indeed have been zero.

           01000101 //The number 69, stored in an 8 bit object
(01000101) 00000000 //shifted left by 8
 ^^^^^^^^
these bits have been shifted outside the size of the object.

The same thing would happen if you shifted an int by 32.

00000000 00000000 00000000 01000101 //The number 69, stored in a 32 bit int
00000000 00000000 01010000 00000000 //shifted left by 8
00000000 01010000 00000000 00000000 //shifted left by 16
01010000 00000000 00000000 00000000 //shifted left by 24
00000000 00000000 00000000 00000000 //shifted left by 32, overflow

edited Jun 27 '19 at 08:07

answered Feb 25 '16 at 00:20

ApproachingDarknessFish

14,133
7
40
79

2

wrong. (bit shift) operators act on expressions, not variables. – wildplasser Feb 25 '16 at 00:22
@wildplasser replaced "variable" with "object." – ApproachingDarknessFish Feb 25 '16 at 00:30
It is not an object (it need not have an addres, for instance) . It is an **expression**. consider the case `(a+b) < – wildplasser Feb 25 '16 at 00:34
1

@wildplasser "A 32-bit expression" makes no sense to me. How do you suggest I rephrase my answer? – ApproachingDarknessFish Feb 25 '16 at 01:17

What happens with bitwise shift for all 8 bits

2 Answers2

Linked