Thread: Bitwise operations

anyone no of any good sites on bitwise operations not directly relating to game programming?

have you tried http://www.cprogramming.com/tutorial...operators.html

Bitwise operations are farily simple. The tutorial may cover everything! The thing that makes it hard for beginners is that cin and cout don't directly support binary, so you can't easily "see" what you are doing.

You can write your own code to display (and input) binary numbers, or you can use <bitset> to display numbers in binary format, and strtoul() to input a c-style string that represents a binary number (or a number in almost any other base).

However, most real-world programs that use bit manipulation use cin and cout with hexadecimal representation. It is very easy to convert between hex and binary. (You can learn to do it in your head.)

Bitwise operations are most-often used when you are programming "close to the hardware" (drivers or firmware), or with assembly-language programming. The state of one particular bit might represent the on/off state of an LED, or the on/off state of a switch, etc.

And, we usually don't care about the numerical value of the binary number.... We are only concerned with the value of a particular bit, or the "bit pattern". We don't care that 1111 (binary) equals 15 (decimal), or F (hex). We just want to know that all of the bits are "set".

I guess it's not the actual operations that confuse me, it's when do you use them.

Bitwise operations are used to talk directly to hardware? I guess I'm just used to dealing with a layer of abstraction,.

So, maybe an easy example of how to 'talk' to the hardware or 'addresses' so I can see how it's done, if at all possible?

Many thanx!

I'd say the following are the MOST common uses of bitwise operators, although there are certainly others:

1. Storing binary flags inside integer variables. A single int can hold many flags (on many systems, up to 32 of them). You could do this with 32 separate variables, but using a single int is much cheaper, and it allows you to do more complex things to the flags by using bitwise operators.

2. Talking to hardware. Hardware often takes commands in the forms of single bytes or words, each bit of which represents some flag or status to be set/retrieved from the hardware. You need bitwise operators to send and interpret these results.

3. Accessing the individual bits of a 1-bit bitmap image.

Other fun uses include bitboards in AI chess programming, encryption, etc...

if found this example at http://www.fredosaurus.com/notes-cpp...s/bitops.html:

Code:

int age, gender, height, packed_info;
    
. . .   // Assign values 

// Pack as AAAAAAA G HHHHHHH using shifts and "or"
packed_info = (age << 8) | (gender << 7) | height;

// Unpack with shifts and masking using "and"
height = packed_info & 0x7F;   // This constant is binary ...01111111
gender = (packed_info >> 7) & 1;
age    = (packed_info >> 8);

which seems to explain a little bit.

I don't however understand the line:

Code:

height = packed_info & 0x7F;

Is this good practice? to purposely mask numbers in one larger number? is this much more efficient than not dong this?

also, is 2's complement the standard? how do you know what binary system is being used?

I always use an unsigned type for array/vector indices, and for these it's safe to use the bitwise forms (hk_mp5kpdw should have pointed out that the "unsigned" part of the declaration is important, and the two's complement/ones' complement/sign-magnitude issue only applies to signed types).