When is a shift operator >> or << useful?

Question

Possible Duplicate:
When to use Shift operators << >> in C# ?

I've in programming a while and I've never used the shift operator. I could see how it could be helpful for calculating hash codes like in Tuple<T>, but other than that,

When and how is the shift operator useful in C#/.NET?

Answer 1

In general it's not used very often. But it's very useful when dealing with bit level operations. For example printing out the bits in a numeric value

public static string GetBits(int value) {
  var builder = new StringBuilder();
  for (int i = 0; i < 32; i++) {
    var test = 1 << (31 - i);    
    var isSet = 0 != (test & value);
    builder.Append(isSet ? '1' : '0');
  }
  return builder.ToString();
}

Answer 2

It's useful to write powers of two.

Quick: What's 2²⁷?
Answer: 1 << 27

Writing 1 << 27 is both easier and more understandable than 134217728.

Answer 3

I use it rather a lot in dealing with hardware. This isn't something you probably do in C# a lot, but the operator was inherited from C/C++ where it is a fairly common need.

Example 1:

I just got a longword from a little-endian machine, but I'm big endian. How do I convert it? Well, the obvious is call htonl() (you cheater). One of the manual ways to do it is with something like the following:

        ((source & 0x000000ff) << 24 ) |
        ((source & 0x0000ff00) << 8) |
        ((source & 0x00ff0000) >> 8) |
        ((source & 0xff000000) >> 24);

Example 2:

I have a DMA device that only allows longword accesses of up to 512K. So it requires me to put (for reasons only understood by hardware folks) the modulo 4 of the transfer size into the high order 18 bits of a DMA transfer control register. For the sake of arguement, the low-order bits are to be filled with various flags controlling the DMA operation. That would be accomplished like so:

dma_flags | ((length & 0xffffc) << 14);

These might not be the kind of things you do every day. But for those of us that regularly interface to hardware they are.

Answer 4

If you ever need to multiply without using * How to implement multiplication without using multiplication operator in .NET :)

Or write a Sudoku solver Sudoku validity check algorithm - how does this code works?

In practice, the only time I've seen it used in my (limited) experience was as an (arguably) confusing way to multiply (see first link) or in conjunction with setting BitFlags (the Sudoku solver above).

In .NET I rarely have to work at the bit level; but if you need to, being able to shift is important.

Answer 5

Bitwise operators are good for saving space, but nowadays, space is hardly an issue.

It's useful when multiplying by powers of 2

number<<power;

is number*2^power

And of course division by powers of 2:

number>>power;

Another place is flags in enums.

when you come across code like

Regex re = new Regex(".",RegexOptions.Multiline|RegexOptions.Singleline);

the ability to use RegexOptions.Multiline|RegexOptions.Singleline i.e multiple flags is enabled through the shifting and also this allows them to be unique.

Something like:

enum RegexOptions {
  Multiline  = (1 << 0), 
  Singleline = (1<<1)
};

Answer 6

Bit shifts are used when manipulating individual bits is desired. You'll see a lot of bit shifts in many encryption algorithms, for example.

In optimization, it can used in place of multiplication/division. A shift left is equal to multiplying by two. Shift right equals division. You probably don't see this done anymore, since this level of optimization is often unnecessary.

Other than that, I can't think of many reasons to use it. I've seen it used before, but rarely in cases where it was really required and usually a more readable method could have been used.

Answer 7

Whenever you need to multiply by 2 ;)

Really the only use I have is for interoperability code and bitfields:

http://www.codeproject.com/KB/cs/masksandflags.aspx