What does a bitwise shift (left or right) do and what is it used for?

Question

I've seen the operators >> and << in various code that I've looked at (none of which I actually understood), but I'm just wondering what they actually do and what some practical uses of them are.

If the shifts are like x * 2 and x / 2, what is the real difference from actually using the * and / operators? Is there a performance difference?

Googling for "bitwise shift" and looking at the first result (Wikipedia) probably isn't that hard. It also answers all of the above. — Jon, Jun 17 '11 at 12:38
Yes, off-course there should be a performance difference. Please see this [link] (http://www.dotnetperls.com/shift) — Waqas Shabbir, Jul 23 '15 at 05:12
Possible duplicate of [What are bitwise shift (bit-shift) operators and how do they work?](http://stackoverflow.com/questions/141525/what-are-bitwise-shift-bit-shift-operators-and-how-do-they-work) — TylerH, Oct 19 '15 at 20:06

score 52 · Answer 1 · edited Aug 14 '20 at 16:12

52

Here is an applet where you can exercise some bit-operations, including shifting.

You have a collection of bits, and you move some of them beyond their bounds:

1111 1110 << 2
1111 1000

It is filled from the right with fresh zeros. :)

0001 1111 >> 3
0000 0011

Filled from the left. A special case is the leading 1. It often indicates a negative value - depending on the language and datatype. So often it is wanted, that if you shift right, the first bit stays as it is.

1100 1100 >> 1
1110 0110

And it is conserved over multiple shifts:

1100 1100 >> 2
1111 0011

If you don't want the first bit to be preserved, you use (in Java, Scala, C++, C as far as I know, and maybe more) a triple-sign-operator:

1100 1100 >>> 1
0110 0110

There isn't any equivalent in the other direction, because it doesn't make any sense - maybe in your very special context, but not in general.

Mathematically, a left-shift is a *=2, 2 left-shifts is a *=4 and so on. A right-shift is a /= 2 and so on.

edited Aug 14 '20 at 16:12

Peter Mortensen

30,738
21
105
131

answered Jun 17 '11 at 12:42

user unknown

35,537
11
75
121

7

ANSI C defines only the two bitwise shift operators >> and <<. – TML Jun 17 '11 at 20:01
1

@TML: ANSI C isn't the only language which uses bitwise shift operators. C++ uses them too and Java does, doesn't it? I guess there are even more languages. and I don't ses "C" in the headlinen, nor in the text or tags of the question. – user unknown Jan 20 '15 at 20:16
2

No, the question doesn't; which is why I still upvoted you. But at the time (admittedly, this was almost 4 years ago) I felt it was a valuable comment to add. :) – TML Jan 22 '15 at 02:11
Does it go `2` `4` `6` `8` or `2` `4` `8` `16`? – S.S. Anne Apr 29 '19 at 23:13
@JL2210: Don't you have the possibility to try it out? Or to calculate it with pen and paper? Since I wrote *=2, and not +=2, it should be the latter, shouldn't it? – user unknown Apr 30 '19 at 22:18
I think I understand now. I was just wondering because I needed to multiply a pointer by 16. – S.S. Anne Apr 30 '19 at 23:08

score 37 · Answer 2 · edited Aug 14 '20 at 16:12

37

Left bit shifting to multiply by any power of two and right bit shifting to divide by any power of two.

For example, x = x * 2; can also be written as x<<1 or x = x*8 can be written as x<<3 (since 2 to the power of 3 is 8). Similarly x = x / 2; is x>>1 and so on.

edited Aug 14 '20 at 16:12

Peter Mortensen

30,738
21
105
131

answered Jun 17 '11 at 12:39

Nitish

2,695
9
53
88

score 25 · Answer 3 · edited Oct 01 '15 at 08:13

25

Left Shift

x = x * 2^value (normal operation)

x << value (bit-wise operation)

x = x * 16 (which is the same as 2^4)

The left shift equivalent would be x = x << 4

Right Shift

x = x / 2^value (normal arithmetic operation)

x >> value (bit-wise operation)

x = x / 8 (which is the same as 2^3)

The right shift equivalent would be x = x >> 3

edited Oct 01 '15 at 08:13

Till Helge

9,253
2
40
56

answered Jul 29 '15 at 10:28

loyola

3,905
2
24
18

score 16 · Answer 4 · edited Aug 14 '20 at 16:14

Left shift: It is equal to the product of the value which has to be shifted and 2 raised to the power of number of bits to be shifted.

Example:

1 << 3
0000 0001  ---> 1
Shift by 1 bit
0000 0010 ----> 2 which is equal to 1*2^1
Shift By 2 bits
0000 0100 ----> 4 which is equal to 1*2^2
Shift by 3 bits
0000 1000 ----> 8 which is equal to 1*2^3

Right shift: It is equal to quotient of value which has to be shifted by 2 raised to the power of number of bits to be shifted.

Example:

8 >> 3
0000 1000  ---> 8 which is equal to 8/2^0
Shift by 1 bit
0000 0100 ----> 4 which is equal to 8/2^1
Shift By 2 bits
0000 0010 ----> 2 which is equal to 8/2^2
Shift by 3 bits
0000 0001 ----> 1 which is equal to 8/2^3

score 3 · Answer 5 · edited Aug 14 '20 at 16:15

3

The bit shift operators are more efficient as compared to the / or * operators.

In computer architecture, divide(/) or multiply(*) take more than one time unit and register to compute result, while, bit shift operator, is just one one register and one time unit computation.

edited Aug 14 '20 at 16:15

Peter Mortensen

30,738
21
105
131

answered Jul 22 '15 at 08:43

Shobhit Raj

69
4

Isn't there one-cycle multiplication with modern CPUs? – Peter Mortensen Aug 14 '20 at 16:15

score 3 · Answer 6 · answered Apr 05 '17 at 16:30

3

Left bit shifting to multiply by any power of two. Right bit shifting to divide by any power of two.

x = x << 5; // Left shift
y = y >> 5; // Right shift

In C/C++ it can be written as,

#include <math.h>

x = x * pow(2, 5);
y = y / pow(2, 5);

answered Apr 05 '17 at 16:30

Pabitra Dash

1,461
2
21
28

score 2 · Answer 7 · edited Aug 14 '20 at 16:20

Yes, I think performance-wise you might find a difference as bitwise left and right shift operations can be performed with a complexity of o(1) with a huge data set.

For example, calculating the power of 2 ^ n:

int value = 1;
while (exponent<n)
    {
       // Print out current power of 2
        value = value *2; // Equivalent machine level left shift bit wise operation
        exponent++;
         }
    }

Similar code with a bitwise left shift operation would be like:

value = 1 << n;

Moreover, performing a bit-wise operation is like exacting a replica of user level mathematical operations (which is the final machine level instructions processed by the microcontroller and processor).

score 2 · Answer 8 · edited Aug 14 '20 at 16:17

2

Some examples:

Bit operations for example converting to and from Base64 (which is 6 bits instead of 8)
doing power of 2 operations (1 << 4 equal to 2^4 i.e. 16)
Writing more readable code when working with bits. For example, defining constants using 1 << 4 or 1 << 5 is more readable.

edited Aug 14 '20 at 16:17

Peter Mortensen

30,738
21
105
131

answered Jun 17 '11 at 12:37

Aliostad

80,612
21
160
208

score 0 · Answer 9 · edited Aug 14 '20 at 16:26

0

Here is an example:

#include"stdio.h"
#include"conio.h"

void main()
{
    int rm, vivek;
    clrscr();
    printf("Enter any numbers\t(E.g., 1, 2, 5");
    scanf("%d", &rm); // rm = 5(0101) << 2 (two step add zero's), so the value is 10100
    printf("This left shift value%d=%d", rm, rm<<4);
    printf("This right shift value%d=%d", rm, rm>>2);
    getch();
}

edited Aug 14 '20 at 16:26

Peter Mortensen

30,738
21
105
131

answered Oct 07 '14 at 07:56

R.M.VIVEK Arni

1
3

What does a bitwise shift (left or right) do and what is it used for?

9 Answers9

Left Shift

Right Shift

Linked

Related