#### [SOLVED] What are bitwise shift (bit-shift) operators and how do they work?

I've been attempting to learn C in my spare time, and other languages (C#, Java, etc.) have the same concept (and often the same operators) ...

What I'm wondering is, at a core level, what does bit-shifting (`<<`, `>>`, `>>>`) do, what problems can it help solve, and what gotchas lurk around the bend? In other words, an absolute beginner's guide to bit shifting in all its goodness.

#### @Amin Ahmed 2019-04-27 18:40:24

Some useful bit operations/manipulations in Python.

I implemented Ravi Prakash's answer in Python.

``````# Basic bit operations
# Integer to binary
print(bin(10))

# Binary to integer
print(int('1010', 2))

# Multiplying x with 2 .... x**2 == x << 1
print(200 << 1)

# Dividing x with 2 .... x/2 == x >> 1
print(200 >> 1)

# Modulo x with 2 .... x % 2 == x & 1
if 20 & 1 == 0:
print("20 is a even number")

# Check if n is power of 2: check !(n & (n-1))
print(not(33 & (33-1)))

# Getting xth bit of n: (n >> x) & 1
print((10 >> 2) & 1) # Bin of 10 == 1010 and second bit is 0

# Toggle nth bit of x : x^(1 << n)
# take bin(10) == 1010 and toggling second bit in bin(10) we get 1110 === bin(14)
print(10^(1 << 2))
``````

#### @Ravi Prakash 2016-10-11 22:43:54

I am writing tips and tricks only. It may be useful in tests and exams.

1. `n = n*2`: `n = n<<1`
2. `n = n/2`: `n = n>>1`
3. Checking if n is power of 2 (1,2,4,8,...): check `!(n & (n-1))`
4. Getting xth bit of `n`: `n |= (1 << x)`
5. Checking if x is even or odd: `x&1 == 0` (even)
6. Toggle the nth bit of x: `x ^ (1<<n)`

#### @ryyker 2017-06-06 13:31:18

There must be a few more that you know by now?

#### @Ravi Prakash 2018-06-10 18:19:57

@ryyker I have added a few more. I will try to keep updating it :)

#### @reggaeguitar 2018-10-06 00:41:40

Are x and n 0 indexed?

#### @Peter Mortensen 2020-01-07 04:46:17

Ad 5.: What if it is a negative number?

#### @Willy satrio nugroho 2020-01-18 07:52:11

so, can we conclude 2 in binary is like 10 in decimal? and bit shifting is like adding or substracting one more number behind another number in decimal ?

#### @Basti Funck 2015-03-31 10:49:23

Bit shifting is often used in low-level graphics programming. For example, a given pixel color value encoded in a 32-bit word.

`````` Pixel-Color Value in Hex:    B9B9B900
Pixel-Color Value in Binary: 10111001  10111001  10111001  00000000
``````

For better understanding, the same binary value labeled with what sections represent what color part.

``````                                 Red     Green     Blue       Alpha
Pixel-Color Value in Binary: 10111001  10111001  10111001  00000000
``````

Let's say for example we want to get the green value of this pixel's color. We can easily get that value by masking and shifting.

``````                  Red      Green      Blue      Alpha
color :        10111001  10111001  10111001  00000000
green_mask  :  00000000  11111111  00000000  00000000

``````

The logical `&` operator ensures that only the values where the mask is 1 are kept. The last thing we now have to do, is to get the correct integer value by shifting all those bits to the right by 16 places (logical right shift).

`````` green_value = masked_color >>> 16
``````

Et voilĂ , we have the integer representing the amount of green in the pixel's color:

`````` Pixels-Green Value in Hex:     000000B9
Pixels-Green Value in Binary:  00000000 00000000 00000000 10111001
Pixels-Green Value in Decimal: 185
``````

This is often used for encoding or decoding image formats like `jpg`, `png`, etc.

#### @David H Parry 2019-10-13 18:12:54

Isn't it easier to cast your original, say 32bit cl_uint, as something like cl_uchar4 and access the byte you want directly as *.s2?

#### @FlySwat 2008-09-26 19:55:11

Let's say we have a single byte:

``````0110110
``````

Applying a single left bitshift gets us:

``````1101100
``````

The leftmost zero was shifted out of the byte, and a new zero was appended to the right end of the byte.

The bits don't rollover; they are discarded. That means if you left shift 1101100 and then right shift it, you won't get the same result back.

Shifting left by N is equivalent to multiplying by 2N.

Shifting right by N is (if you are using ones' complement) is the equivalent of dividing by 2N and rounding to zero.

Bitshifting can be used for insanely fast multiplication and division, provided you are working with a power of 2. Almost all low-level graphics routines use bitshifting.

For example, way back in the olden days, we used mode 13h (320x200 256 colors) for games. In Mode 13h, the video memory was laid out sequentially per pixel. That meant to calculate the location for a pixel, you would use the following math:

``````memoryOffset = (row * 320) + column
``````

Now, back in that day and age, speed was critical, so we would use bitshifts to do this operation.

However, 320 is not a power of two, so to get around this we have to find out what is a power of two that added together makes 320:

``````(row * 320) = (row * 256) + (row * 64)
``````

Now we can convert that into left shifts:

``````(row * 320) = (row << 8) + (row << 6)
``````

For a final result of:

``````memoryOffset = ((row << 8) + (row << 6)) + column
``````

Now we get the same offset as before, except instead of an expensive multiplication operation, we use the two bitshifts...in x86 it would be something like this (note, it's been forever since I've done assembly (editor's note: corrected a couple mistakes and added a 32-bit example)):

``````mov ax, 320; 2 cycles
mul word [row]; 22 CPU Cycles
mov di,ax; 2 cycles
; di = [row]*320 + [column]

; [di] is a valid addressing mode, but [ax] isn't, otherwise we could skip the last mov
``````

Total: 28 cycles on whatever ancient CPU had these timings.

Vrs

``````mov ax, [row]; 2 cycles
mov di, ax; 2
shl ax, 6;  2
shl di, 8;  2
add di, ax; 2    (320 = 256+64)
; di = [row]*(256+64) + [column]
``````

12 cycles on the same ancient CPU.

Yes, we would work this hard to shave off 16 CPU cycles.

In 32 or 64-bit mode, both versions get a lot shorter and faster. Modern out-of-order execution CPUs like Intel Skylake (see http://agner.org/optimize/) have very fast hardware multiply (low latency and high throughput), so the gain is much smaller. AMD Bulldozer-family is a bit slower, especially for 64-bit multiply. On Intel CPUs, and AMD Ryzen, two shifts are slightly lower latency but more instructions than a multiply (which may lead to lower throughput):

``````imul edi, [row], 320    ; 3 cycle latency from [row] being ready
add  edi, [column]      ; 1 cycle latency (from [column] and edi being ready).
; edi = [row]*(256+64) + [column],  in 4 cycles from [row] being ready.
``````

vs.

``````mov edi, [row]
shl edi, 6               ; row*64.   1 cycle latency
lea edi, [edi + edi*4]   ; row*(64 + 64*4).  1 cycle latency
add edi, [column]        ; 1 cycle latency from edi and [column] both being ready
; edi = [row]*(256+64) + [column],  in 3 cycles from [row] being ready.
``````

Compilers will do this for you: See how GCC, Clang, and Microsoft Visual C++ all use shift+lea when optimizing `return 320*row + col;`.

The most interesting thing to note here is that x86 has a shift-and-add instruction (`LEA`) that can do small left shifts and add at the same time, with the performance as an `add` instruction. ARM is even more powerful: one operand of any instruction can be left or right shifted for free. So scaling by a compile-time-constant that's known to be a power-of-2 can be even more efficient than a multiply.

OK, back in the modern days... something more useful now would be to use bitshifting to store two 8-bit values in a 16-bit integer. For example, in C#:

``````// Byte1: 11110000
// Byte2: 00001111

Int16 value = ((byte)(Byte1 >> 8) | Byte2));

// value = 000011111110000;
``````

In C++, compilers should do this for you if you used a `struct` with two 8-bit members, but in practice they don't always.

#### @Joe Pineda 2008-09-26 20:44:36

Expanding this, on Intel processors (and a lot of others) it's faster to do this: int c, d; c=d<<2; Than this: c=4*d; Sometimes, even "c=d<<2 + d<<1" is faster than "c=6*d"!! I used these tricks extensively for graphic functions in the DOS era, I don't think they're so useful anymore...

#### @James Thompson 2011-10-25 00:48:14

@Joe: If these tricks aren't useful anymore, does that mean that compiler writers are using them now?

#### @Joe Pineda 2012-08-29 02:03:30

@James: not quite, nowadays it's rather the video-card's firmware which includes code like that, to be executed by the GPU rather than the CPU. So theoretically you don't need to implement code like this (or like Carmack's black-magic inverse root function) for graphic functions :-)

#### @greggo 2014-10-30 14:17:57

@JoePineda @james The compiler writers are definitely using them. If you write `c=4*d` you will get a shift. If you write `k = (n<0)` that may be done with shifts too: `k = (n>>31)&1` to avoid a branch. Bottom line, this improvement in cleverness of compilers means it's now unnecessary to use these tricks in the C code, and they compromise readability and portability. Still very good to know them if you're writing e.g. SSE vector code; or any situation where you need it fast and there's a trick which the compiler isn't using (e.g. GPU code).

#### @greggo 2014-10-30 14:28:39

Another good example: very common thing is `if(x >= 1 && x <= 9)` which can be done as `if( (unsigned)(x-1) <=(unsigned)(9-1))` Changing two conditional tests to one can be a big speed advantage; especially when it allows predicated execution instead of branches. I used this for years (where justified) until I noticed abt 10 years ago that compilers had started doing this transform in the optimizer, then I stopped. Still good to know, since there are similar situations where the compiler can't make the transform for you. Or if you're working on a compiler.

#### @Mason Watmough 2016-01-01 03:26:01

Is there a reason that your "byte" is only 7 bits?

#### @Derek Park 2008-09-26 20:46:39

The bit shifting operators do exactly what their name implies. They shift bits. Here's a brief (or not-so-brief) introduction to the different shift operators.

## The Operators

• `>>` is the arithmetic (or signed) right shift operator.
• `>>>` is the logical (or unsigned) right shift operator.
• `<<` is the left shift operator, and meets the needs of both logical and arithmetic shifts.

All of these operators can be applied to integer values (`int`, `long`, possibly `short` and `byte` or `char`). In some languages, applying the shift operators to any datatype smaller than `int` automatically resizes the operand to be an `int`.

Note that `<<<` is not an operator, because it would be redundant.

Also note that C and C++ do not distinguish between the right shift operators. They provide only the `>>` operator, and the right-shifting behavior is implementation defined for signed types. The rest of the answer uses the C# / Java operators.

(In all mainstream C and C++ implementations including GCC and Clang/LLVM, `>>` on signed types is arithmetic. Some code assumes this, but it isn't something the standard guarantees. It's not undefined, though; the standard requires implementations to define it one way or another. However, left shifts of negative signed numbers is undefined behaviour (signed integer overflow). So unless you need arithmetic right shift, it's usually a good idea to do your bit-shifting with unsigned types.)

## Left shift (<<)

Integers are stored, in memory, as a series of bits. For example, the number 6 stored as a 32-bit `int` would be:

``````00000000 00000000 00000000 00000110
``````

Shifting this bit pattern to the left one position (`6 << 1`) would result in the number 12:

``````00000000 00000000 00000000 00001100
``````

As you can see, the digits have shifted to the left by one position, and the last digit on the right is filled with a zero. You might also note that shifting left is equivalent to multiplication by powers of 2. So `6 << 1` is equivalent to `6 * 2`, and `6 << 3` is equivalent to `6 * 8`. A good optimizing compiler will replace multiplications with shifts when possible.

### Non-circular shifting

Please note that these are not circular shifts. Shifting this value to the left by one position (`3,758,096,384 << 1`):

``````11100000 00000000 00000000 00000000
``````

results in 3,221,225,472:

``````11000000 00000000 00000000 00000000
``````

The digit that gets shifted "off the end" is lost. It does not wrap around.

## Logical right shift (>>>)

A logical right shift is the converse to the left shift. Rather than moving bits to the left, they simply move to the right. For example, shifting the number 12:

``````00000000 00000000 00000000 00001100
``````

to the right by one position (`12 >>> 1`) will get back our original 6:

``````00000000 00000000 00000000 00000110
``````

So we see that shifting to the right is equivalent to division by powers of 2.

### Lost bits are gone

However, a shift cannot reclaim "lost" bits. For example, if we shift this pattern:

``````00111000 00000000 00000000 00000110
``````

to the left 4 positions (`939,524,102 << 4`), we get 2,147,483,744:

``````10000000 00000000 00000000 01100000
``````

and then shifting back (`(939,524,102 << 4) >>> 4`) we get 134,217,734:

``````00001000 00000000 00000000 00000110
``````

We cannot get back our original value once we have lost bits.

# Arithmetic right shift (>>)

The arithmetic right shift is exactly like the logical right shift, except instead of padding with zero, it pads with the most significant bit. This is because the most significant bit is the sign bit, or the bit that distinguishes positive and negative numbers. By padding with the most significant bit, the arithmetic right shift is sign-preserving.

For example, if we interpret this bit pattern as a negative number:

``````10000000 00000000 00000000 01100000
``````

we have the number -2,147,483,552. Shifting this to the right 4 positions with the arithmetic shift (-2,147,483,552 >> 4) would give us:

``````11111000 00000000 00000000 00000110
``````

or the number -134,217,722.

So we see that we have preserved the sign of our negative numbers by using the arithmetic right shift, rather than the logical right shift. And once again, we see that we are performing division by powers of 2.

#### @FlySwat 2008-09-26 22:00:02

>> and >>> are equivalent in C, which he is probably used too.

#### @Michael Burr 2008-10-20 06:33:42

The answer should make it more clear that this a Java-specific answer. There is no >>> operator in C/C++ or C#, and whether or not >> propagates the sign is implementation defined in C/C++ (a major potential gotcha)

#### @AnT 2010-06-08 22:19:25

The answer is totally incorrect in the context of C language. There's no meaningful division into "arithmetic" and "logical" shifts in C. In C the shifts work as expected on unsigned values and on positive signed values - they just shift bits. On negative values, right-shift is implementation defined (i.e. nothing can be said about what it does in general), and left-shift is simply prohibited - it produces undefined behavior.

#### @Derek Park 2010-07-09 23:08:18

Michael, this is addressed in the answer: Also note that C and C++ do not distinguish between the right shift operators. They provide only the >> operator, and the shifting behavior is implementation defined.

#### @Derek Park 2010-07-09 23:09:06

Audrey, there is certainly a difference between arithmetic and logical right shifting. C simply leaves the choice implementation defined. And left shift on negative values is definitely not prohibited. Shift 0xff000000 to the left one bit and you'll get 0xfe000000.

#### @Mob 2011-10-09 12:45:44

@DerekPark Thanks for this! Its far more better than books I've read!

#### @Geek 2012-08-10 07:21:19

@DerekPark suppose I multiple a big negative number by 2 . In that case left shift would cause us to loose the signed bit which is was the most siginificant bit . How do we get back the sign after this because obviously the answer has to be negative ?

#### @Derek Park 2012-09-21 15:36:03

@Geek, if you multiply a large enough negative number, you'll underflow and end up with a positive number. You'll get the same effect if you shift. e.g. with 32-bit signed integers, -2000000000 << 1 == -2000000000 * 2 == 294967296. You can't "get back" the sign bit, because the answer is not negative. Integral arithmetic is modular in C, Java, and similar languages.

#### @Mahn 2013-06-14 11:45:01

`A good optimizing compiler will substitute shifts for multiplications when possible.` What? Bitshifts are orders of magnitude faster when it comes down to the low level operations of a CPU, a good optimizing compiler would do the exact opposite, that is, turning ordinary multiplications by powers of two into bit shifts.

#### @Hungry Blue Dev 2014-01-11 08:12:33

Well, I wanna know that why bit-shifting is not applicable for `double` and `float` data types. Any help please?

#### @Derek Park 2014-01-27 22:13:42

@Mahn, you're reading it backwards from my intent. Substitute Y for X means to replace X with Y. Y is the substitute for X. So the shift is the substitute for the multiplication.

#### @Derek Park 2014-01-27 22:25:56

@ambigram_maker, in a sense, bit shifting is not even applicable to integers, because it operates on bit fields, a lower level of abstraction. C-style languages generally overload the integral types to represent both whole numbers and bit fields, but this is basically historical coincidence. Shifts could be defined for floating-point types, but the effect would be equivalent to casting to an integer type of the same size, shifting, and casting back to the floating point type. This would result in junk most of the time, though, whereas a shift on an integer happens to produce a useful result.

#### @Søren Løvborg 2014-08-01 19:28:50

In C/C++, left-shifting of negative values (or left-shifting "into the sign bit") is not allowed. From the C99 standard, §6.5.7.4 (given the expression "E1 << E2"): "If E1 has a signed type and nonnegative value, and E1 * 2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined." As always with "undefined" behavior, it may work one moment and crash the next.

#### @Paul Brewczynski 2014-08-04 09:34:34

@DerekPark "A good optimizing compiler will substitute shifts for multiplications when possible." He got 3 UPs and you got one which could suggest that pretty decent amount of people could misunderstood. Why not edit it using simpler English since not all here are native in English?

#### @greggo 2014-10-28 17:51:45

@SørenLøvborg that's pretty surprising - the amount of code which assumes that 'and nonnegative value' isn't in that phrase is huge. And machines where it won't work are virtually all in museums. But there it is. I would have thought it would be 'implementation defined'. To avoid this issue, one can write `n<<3` as `n*8`, and `n<<k` as `n*(1<<k)`. Have just checked that gcc and clang treat that the same as `n<<k`. There may well be compilers that leave the multiply in, though.

#### @Søren Løvborg 2014-10-29 20:04:50

@greggo: Doesn't entirely solve the problem, since signed integer overflow is also undefined behavior. :-) But yes, as a rule, bit operators are best reserved for unsigned integers. And remember, undefined behavior is not as much about "what the CPU would do", as it's about the optimizer doing surprising things to your code. For instance, if you write `y = x << 3; if (x < 0) {...}`, the C standard says that the compiler may rightfully leave out the entire `if` block... because you just promised it that `x` is guaranteed to be non-negative!

#### @greggo 2014-10-29 22:31:23

@SørenLøvborg Interesting. So, a compiler which does adds and subtracts and shifts etc as per '2's complement' convention (left shift and add/sub and multiply being bitwise equivalent to the corresponding unsigned ops) - and which considers this, even with overflow, as defined behaviour wrt the kind of optimization you mention -- is actually providing a language extension. One which I believe all major compilers supply, and which would be troublesome to retract. But I can see why the standards group would want to leave this outside the spec.

#### @Søren Løvborg 2014-10-30 16:48:12

@greggo I just tested GCC 4.8 and Clang 3.4, and neither optimized out the block in my example, but the list of people being bitten by signed integer overflow optimizations is long. C compilers generally go beyond the C standard, though, mostly to avoid complaints from people who, perhaps, had too much faith in internet posts like this answer, which remains blatantly wrong for C/C++. (You can enable `-fwrapv` if you really must have well-defined signed overflows, but you're no longer writing standard C.)

#### @MrAP 2017-02-18 08:10:05

In the 11th line, "distingiush" should be "distinguish".

#### @tail_recursion 2018-02-15 12:36:51

If this is indeed specific to Java like @MichaelBurr points out can a mod or someone edit this? It is the very first thing that pops up in Google when you search for bit shifting.

#### @timur 2018-04-08 19:16:29

I don't understand why <<< would be redundant, since << would supposedly push out the sign bit.

#### @Frax 2018-04-13 20:02:47

@timur: it's because of how representation of negative numbers works. For the higher (i.e. closer to 0) half of the negative numbers the second bit is 1 (so shifting all bits like in logical shift keeps the number negative, no need for a special action), and for the other half the shift results in an underflow anyway, so breaking the sign bit doesn't really matter.

#### @waseefakhtar 2019-11-24 18:17:06

Such a great explanation! This has just opened so many different doors for me!

#### @lukyer 2015-10-23 14:28:36

Be aware of that only 32 bit version of PHP is available on the Windows platform.

Then if you for instance shift << or >> more than by 31 bits, results are unexpectable. Usually the original number instead of zeros will be returned, and it can be a really tricky bug.

Of course if you use 64 bit version of PHP (Unix), you should avoid shifting by more than 63 bits. However, for instance, MySQL uses the 64-bit BIGINT, so there should not be any compatibility problems.

UPDATE: From PHP 7 Windows, PHP builds are finally able to use full 64 bit integers: The size of an integer is platform-dependent, although a maximum value of about two billion is the usual value (that's 32 bits signed). 64-bit platforms usually have a maximum value of about 9E18, except on Windows prior to PHP 7, where it was always 32 bit.

#### @Patrick Monkelban 2015-08-28 13:16:33

Note that in the Java implementation, the number of bits to shift is mod'd by the size of the source.

For example:

``````(long) 4 >> 65
``````

equals 2. You might expect shifting the bits to the right 65 times would zero everything out, but it's actually the equivalent of:

``````(long) 4 >> (65 % 64)
``````

This is true for <<, >>, and >>>. I have not tried it out in other languages.

#### @pizzapants184 2018-01-15 05:25:15

Huh, interesting! In C, this is technically undefined behavior. `gcc 5.4.0` gives a warning, but gives `2` for 5 >> 65; as well.

#### @robottobor 2008-09-26 22:22:03

Bitwise operations, including bit shift, are fundamental to low-level hardware or embedded programming. If you read a specification for a device or even some binary file formats, you will see bytes, words, and dwords, broken up into non-byte aligned bitfields, which contain various values of interest. Accessing these bit-fields for reading/writing is the most common usage.

A simple real example in graphics programming is that a 16-bit pixel is represented as follows:

``````  bit | 15| 14| 13| 12| 11| 10| 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1  | 0 |
|       Blue        |         Green         |       Red          |
``````

To get at the green value you would do this:

`````` #define GREEN_MASK  0x7E0
#define GREEN_OFFSET  5

uint16_t green = (pixel & GREEN_MASK) >> GREEN_OFFSET;
``````

Explanation

In order to obtain the value of green ONLY, which starts at offset 5 and ends at 10 (i.e. 6-bits long), you need to use a (bit) mask, which when applied against the entire 16-bit pixel, will yield only the bits we are interested in.

``````#define GREEN_MASK  0x7E0
``````

The appropriate mask is 0x7E0 which in binary is 0000011111100000 (which is 2016 in decimal).

``````uint16_t green = (pixel & GREEN_MASK) ...;
``````

To apply a mask, you use the AND operator (&).

``````uint16_t green = (pixel & GREEN_MASK) >> GREEN_OFFSET;
``````

After applying the mask, you'll end up with a 16-bit number which is really just a 11-bit number since its MSB is in the 11th bit. Green is actually only 6-bits long, so we need to scale it down using a right shift (11 - 6 = 5), hence the use of 5 as offset (`#define GREEN_OFFSET 5`).

Also common is using bit shifts for fast multiplication and division by powers of 2:

`````` i <<= x;  // i *= 2^x;
i >>= y;  // i /= 2^y;
``````

#### @Saheed 2015-03-31 22:20:04

0x7e0 is the same as 11111100000 which is 2016 in decimal.

#### @AShelly 2008-09-26 20:07:48

One gotcha is that the following is implementation dependent (according to the ANSI standard):

``````char x = -1;
x >> 1;
``````

x can now be 127 (01111111) or still -1 (11111111).

In practice, it's usually the latter.

#### @Joe Pineda 2008-09-26 20:46:30

If I recall it correctly, the ANSI C standard explicitly says this is implementation-dependent, so you need to check your compiler's documentation to see how it's implemented if you want to right-shift signed integers on your code.

#### @Joe Pineda 2008-09-27 00:17:13

Yes, I just wanted to emphasize the ANSI standard itself says so, it's not a case where vendors are simply not following the standard or that the standard says nothing about this particualr case.

### [SOLVED] What is the !! (not not) operator in JavaScript?

• 2009-04-24 08:13:58
• Hexagon Theory
• 517640 View
• 2957 Score
• Tags:   javascript operators

### [SOLVED] What does the C ??!??! operator do?

• 2011-10-19 16:56:59
• Peter Olson
• 254066 View
• 1939 Score
• Tags:   c operators trigraphs

### [SOLVED] What do all of Scala's symbolic operators mean?

• 2011-10-25 12:00:11
• 0__
• 107957 View
• 398 Score
• Tags:   scala operators