The practice problems below cover base conversion, bitwise operators, and constructing bitmasks. Reveal the answers for each section to double-check your work. Please ask questions about anything you don't understand!

A few miscellaneous notes about bit operations as you practice further:

• operator precedence with bit operators and other operators can be tricky. Always use parentheses where precedence is ambiguous just to make sure operators execute in the order you expect. For instance, 1<<2 + 3<<4 means 1 << (2+3) << 4 due to precedence rules. Writing (1<<2) + (3<<4) ensures the correct order.
• put a U after a number literal to make it unsigned. For instance, 1U means the literal 1 as an unsigned number.
• put an L after a number literal to make it a long (64 bits) instead of an int, which it is by default. This highlights a common issue! If you want, for instance, a long with the index-32 bit on and everything else off, the following does not work:

long num = 1 << 32;

This is because the 1 is by default a signed int, and you cannot shift a signed int by 32 spaces because it has only 32 bits. Instead, you must specify that the literal be a long:

long num = 1L << 32;

With this material and the other material from the past lectures, test your understanding with the practice below.

Base Conversion

It is unwieldy to express any type larger than char in binary form, thus hex is an important friend to have. Mapping between base 16 and base 2 is straightforward and you should practice until it is second nature for you to see a hex value and visualize its binary equivalent and vice versa. (Converting between decimal and hex is less worthy of practice, and it is ok for it to be a chore in the isolated situations you have to convert manually.)

There is no need to memorize the entire ASCII table, but knowing the placement of a few key characters from which you can then find neighbors is worthwhile. Use man ascii to learn the codes for the three characters '0' 'A' 'a' and use them to do the following conversions.

You should also know the bit patterns for various distinctive unsigned and signed values.

Unix Tools: gdb

Once you are comfortable with manual bit calculations, it's good to also learn how to use the Unix tools to do these calculations for you. The best tool to use for conversions is the debugger gdb. If you run it (even without a program to debug), you can use it as sort of a converter. The gdb print command (shortened p) defaults to decimal format. Use p/format to instead select other formats such as x for hex, t for binary, and c for char. Also check out the guide to GDB for more information about gdb.

$ gdb
(gdb) p 68
$1 = 68
(gdb) p/x 68
$2 = 44
(gdb) p/c 68
$3 = 'D'
(gdb) p/t 68
$4 = 1000100
(gdb) p 45 << 1        Note: can also print expressions, not just constants
$5 = 90

Another fun and handy tool to play with is this online visualizer for bitwise expressions written by Max Drach, a previous 107 CA. Check it out!

Bitwise Operators

You should know the behavior of all six bitwise operators in C: & | ~ ^ << >>.

Bitvectors

A bitvector is an unsigned value treated as a set of independent booleans. The bit at a given position represents a particular member and if that bit is on in the bitvector, the set contains that member. Changing a particular bit allows you to add or remove a member from the set. When operating on a bitvector, you apply a bitwise operator with a mask to isolate the bits of interest.

Bitwise operators are used to test, set, and clear individual bits and perform simple set operations. These are classic bitwise code idioms worth knowing!

Using and Constructing Bitmasks

When accessing an individual bit, a mask is used to isolate the bit of interest, e.g., 1 is the mask being used to test the least significant bit (mine & 1). Changing the mask changes which bit(s) is being operated on. For example, (mine & 2) tests the second least significant bit. Including other bits into the mask allows you to affect an entire group of bits, e.g., mine ^= 0x7 to toggle the 3 lowest bits.

A constant mask should always be expressed in hex (few of us are good at visualizing binary from decimal, but hex to binary is a snap), the exception being small decimal integer constants (0, 1,...). For a complex mask, it is pleasing to express the mask by its construction, as opposed to hard-coding a magic number. You should practice with building up masks by construction. You should also define constants (#define <CONSTANT> <VALUE> near the top of your file) where appropriate.

Bitwise Manipulation

Lastly, we present some slightly fancier bitwise manipulations. These constructions can be tricky to reason about at first, but working through them confirms you have solid understanding of the bitwise operators and the relationship to the two's complement representation.

Questions about any of these? Post on the discussion forum or come by helper hours!

Source: cowbirdsinlove.com