0

Possible Duplicates:
Have you ever had to use bit shifting in real projects?
When to use Shift operators << >> in C# ?

Although I should have learnt this a long time ago, what coding tasks/scenarios are useful for bitshifts/unary operators and the like?

I never see a need for these in the coding I do (mostly LOB apps), so what sort of tasks/problems would make me come to the conclusion I need to use these concepts?

Thanks

Community
  • 1
  • 1
csharpdev
  • 297
  • 2
  • 5
  • 9

4 Answers4

2

This doesn't work that way, you don't just "need" to use them. It's more that you need to make a given task that happens to be faster if you use a bitshift operation.

Usually there are very few things you "need" them to, but they're useful for performance on a lot of mathematical functions as well as to improve hash functions and other cryptographic operations (which are in fact math based...). Basically, in the majority of the cases, to improve performance of a given algorithm.

Jorge Córdoba
  • 51,063
  • 11
  • 80
  • 130
1

Anything that involves some sort of bit-level encoding, for example UTF-8 and other multi-byte character encodings. In these cases you need to check individual bits and combine bit strings together.

Also the simplest case is when you want to store various flags in a single byte. You might define something like:

const uint FOO_DELETED = 0x01;
const uint FOO_DRAFT = 0x02;
const uint FOO_WHATEVER = 0x04;
// ...

Then you can combine these together in a single byte:

byte my_flags = FOO_DELETED | FOO_WHATEVER;

And extract them:

bool is_deleted = (my_flags & FOO_DELETED);
Mike Weller
  • 45,401
  • 15
  • 131
  • 151
0

Not a ton of use in day-to-day stuff when you live in C#. It's mostly when interoperating with unmanaged code that has sub-byte granularity (struct marshaling, etc), dealing with byte-order conversion (little-endian/big-endian). Under the covers, enums with FlagsAttribute already does it.

Lots of unmanaged stuff uses bitfields for very efficient storage. Bitfields can be a royal pain in C#. I've done some managed user-mode driver framework coding, and some work with the raw TIFF file format in C#, and it sucked. C/C++ have better facilities for dealing with them.

nitzmahone
  • 13,720
  • 2
  • 36
  • 39
0

Another example is to multiply or to divide by 2.

int a = 10;
int result = 0;

result = a << 1; // result is 10 * 2 == 20;
result = a >> 1; // result is 10 / 2 == 5;

These operations are usually much faster than the "real" operator * or /

codencandy
  • 1,701
  • 1
  • 10
  • 20
  • "usually much faster" - have you tried it? – AakashM Dec 22 '09 at 10:44
  • no difference here: `Iterations: 1,000,000,000 x << 1: 4970ms x * 2: 4957ms` I think the runtime already optimizes that. Or even at the cpu level, i'm not sure. – Botz3000 Dec 22 '09 at 10:46
  • usually because the compiler as Botz3000 may optimize these kind of operations. But yes i have used this many many times in embedded systems programming. – codencandy Dec 22 '09 at 10:53