2.11. Supplemental: Bitwise Operators

Some exotic programming sub-disciplines like communications, embedded programming, and cryptography use bitwise operations extensively. Although they are used less frequently in "ordinary" programming, they are necessary for common tasks like file I/O operations, which the text covers in its last chapter. C++ implements bitwise operations with operators, making their inclusion in this chapter appropriate. However, the text doesn't rely on them significantly until it covers file I/O, so it labels them as "supplemental" until revisiting them later.

C++ inherits six bitwise operators from C. Bitwise operations are always available in assembly language but are less common in higher-level languages. Including these operators in C made it possible to write operating systems and device drivers in C rather than in assembly. Most bitwise operators require two integer arguments, but complement is a unary operator. Three operators act on the corresponding bits of the two operands; we can summarize these and the complement operators with truth tables. Two operators treat one operand as a string of bits and shift them to the left or the right. We'll often view one or both operands as a short string of bits for convenience and ease of illustration.

Basic Bitwise Operators

The basic bitwise operators are simple enough to describe them with simple truth tables. When we use these operators, it's convenient to think about or view both operands in binary: 1s and 0s. Each 0-value corresponds to false, and each 1-value corresponds to true. A simple example follows each truth table, illustrating the meaning of "the bitwise operators operate on the corresponding bits of the two operands." Operating on two bits with a bitwise operator produces a single bit. The following figures detail

• the symbol used for each operator,
• the operator's name,
• an exhaustive list of possible inputs with corresponding outputs,
• a simple rule to summarize the behavior of the operator, and
• a simple, 4-bit example. Although the bitwise operators can operate on integers of any size, the examples rely on 4-bit values simplicity. Apply the operator column by column: the pair of bits in each column above the line are the operands, while the bit below the line is the result.

  1100
& 1001
------
  1000

  1100
| 1001
------
  1101

  1100
^ 1001
------
  0101

~ 1100
------
  0011

Viewing the bitwise operations in base-10 is potentially confusing. Nevertheless, they are useful in specialized situations, especially when one operand is a constant. Unfortunately, C++ doesn't have a binary number notation - and long strings of 1s and 0s are problematic. Therefore, programmers typically denote integer constants treated as binary constants with hexadecimal (or occasionally in octal) numbers. A single hexadecimal digit corresponds to a nibble (i.e., to 4 bits). So, we can compactly specify each 4-bit cluster as a single hexadecimal digit.

Bitmasks and Bit Vectors

It's convenient to think of bits as switches: a 1 represents when the switch is on and 0 when it is off. Programmers typically use the logical-AND and logical-OR operators to set (switch on), reset (switch off), and test the bits stored in a multi-bit data structure. Programmers can implement the structures in many ways, but the easiest approach - the one illustrated here - is using the individual bits in an integer. We use the term bit-vector to distinguish an integer representing an integer used as a bit container from one used as a number. The names bit-fields, bit-sets, bit-maps, and bit-strings are synonyms. A constant bit-vector, often symbolically named for convenience, is called a bitmask. Programs often use them to represent common or frequently used switch settings.

Bitwise-AND
a b a & b 0 0 0 0 1 0 1 0 0 1 1 1	1011 0110 = 0xb6 & 0001 1111 = 0x1f ------------------ 0001 0110 = 0x16
(a)	(b)	(c)

Bitwise-OR
a b a | b 0 0 0 0 1 1 1 0 1 1 1 1	1011 0110 = 0xb6 | 1110 0000 = 0xe0 ------------------ 1111 0110 = 0xf6
(a)	(b)	(c)

Bit-Shift Operators

The two bit-shift operators should look familiar to you, not because we have used them before, but because they are reused as the output and input operators introduced previously. Both operands are integers, and we will continue to view the left-hand operand in binary but will now view the right-hand operand in decimal. Both bit-shift operators treat the left-hand operand as a string of 1s and 0s and shift them left or right by the number of places indicated by the right-hand operand. Shifting may seem confusing but is easy to understand when illustrated with an example.

Shifting Left

The left shift operator, << moves the bits in an integer to the left. The right-hand operand specifies how many places to shift the bits. For example:

Shifting Right

The right shift operator, >>, is similar to the left shift operator but is a little more complicated. The right shift operator moves the bits in the left-hand operand to the right by the number of places specified by the right-hand operand. The operation shifts the bits out on the right side, discarding them as expected. However, how the operation fills the empty spaces on the left complicates the right shift operator.

Without programmer intervention, the underlying hardware determines how the spaces vacated by the shift are filled. (The ANSI standard calls such features implementation dependent.) Some hardware implements sign extension (i.e., it fills the empty spaces with a copy of the left-most bit), and some hardware does not (i.e., it fills the empty spaces with 0s).

Fortunately, programmers can intervene. In a signed integer (a number capable of storing negative and positive values), the highest-order bit is called the sign bit. Computers generally treat a number as negative when the sign bit is 1 and non-negative (i.e., zero or positive) when it is 0. Negative values are generally not needed when dealing with bit patterns, and so the easy "fix" is defining the integer as unsigned. (Using unsigned integers, variables, and constants with all the bitwise operators is common.) When the right shift operator's left operand is unsigned, it always fills the empty spaces on the left with 0s regardless of how the hardware behaves by default.

The following examples demonstrate the right shift operator with and without sign extension:

Bitwise Operators With Assignment

Earlier in the chapter, we saw that C++ allows a shorthand notation with arithmetic operators called "Operation With Assignment." We can also use this notation with the binary bitwise operators.