When shifting left, there is no difference between arithmetic and logical shift. When shifting right, the type of shift depends on the type of the value being shifted.

(As background for those readers unfamiliar with the difference, a "logical" right shift by 1 bit shifts all the bits to the right and fills in the leftmost bit with a 0. An "arithmetic" shift leaves the original value in the leftmost bit. The difference becomes important when dealing with negative numbers.)

When shifting an unsigned value, the >> operator in C is a logical shift. When shifting a signed value, the >> operator is an arithmetic shift.

For example, assuming a 32 bit machine:

```
signed int x1 = 5;
assert((x1 >> 1) == 2);
signed int x2 = -5;
assert((x2 >> 1) == -3);
unsigned int x3 = (unsigned int)-5;
assert((x3 >> 1) == 0x7FFFFFFD);
```

Just like the `&`

and `&&`

operator, the double Operator is a "short-circuit" operator.

For example:

```
if(condition1 || condition2 || condition3)
```

If condition1 is true, condition 2 and 3 will NOT be checked.

```
if(condition1 | condition2 | condition3)
```

This will check conditions 2 and 3, even if 1 is already true. As your conditions can be quite expensive functions, you can get a good performance boost by using them.

There is one big caveat, NullReferences or similar problems. For example:

```
if(class != null && class.someVar < 20)
```

If class is null, the if-statement will stop after `class != null`

is false. If you only use &, it will try to check `class.someVar`

and you get a nice `NullReferenceException`

. With the Or-Operator that may not be that much of a trap as it's unlikely that you trigger something bad, but it's something to keep in mind.

No one ever uses the single `&`

or `|`

operators though, unless you have a design where each condition is a function that HAS to be executed. Sounds like a design smell, but sometimes (rarely) it's a clean way to do stuff. The `&`

operator does "run these 3 functions, and if one of them returns false, execute the else block", while the `|`

does "only run the else block if none return false" - can be useful, but as said, often it's a design smell.

There is a Second use of the `|`

and `&`

operator though: Bitwise Operations.

## Best Solution

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 notundefined, though; the standard requires implementations to define it one way or another. However, left shifts of negative signed numbersisundefined 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:Shifting this bit pattern to the left one position (

`6 << 1`

) would result in the number 12: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

notcircular shifts. Shifting this value to the left by one position (`3,758,096,384 << 1`

):results in 3,221,225,472:

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:

to the right by one position (

`12 >>> 1`

) will get back our original 6: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:

to the left 4 positions (

`939,524,102 << 4`

), we get 2,147,483,744:and then shifting back (

`(939,524,102 << 4) >>> 4`

) we get 134,217,734: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

signbit, 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:

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:

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.