2.11. Supplemental: Bitwise Operators

Some courses, like those preparing students for specialized topics like embedded programming or writing device drivers, often cover the bitwise operators in detail, but introductory C++ courses generally do not. Furthermore, providing realistic examples also involves programming structures not introduced until the next chapter. Still, we briefly cover bitwise operators here for completeness and provide a consistent location for later reference and review.

Unless your instructor explicitly assigns this section, you may skip it for now and return later when these operations are more relevant.

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 conveniently 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

a b a & b
0 0 0
0 1 0
1 0 0
1 1 1

12 & 9 = 8

  1100
& 1001
------
  1000
Bitwise-AND. Both operands must be 1 to produce a 1. Bitwise-AND is used to turn off or mask out bits.
a b a | b
0 0 0
0 1 1
1 0 1
1 1 1

12 | 9 = 13

  1100
| 1001
------
  1101
Bitwise-OR. Both operands must be 0 to produce a 0. Bitwise-OR is used to turn on or set a bit to 1.
a b a ^ b
0 0 0
0 1 1
1 0 1
1 1 0

12 ^ 9 = 5

  1100
^ 1001
------
  0101
Bitwise XOR (Exclusive-OR). Operands must be different to produce a 1. XOR is reversible: if A^B=C, then A^C=B, and C^B=A.
a ~a
0 1
1 0

~12 = 3

~ 1100
------
  0011
Bitwise Complement. The bitwise complement operator calculates the one's-complement by toggling the 1's to 0's and the 0's to 1's. Adding 1 to the one's complement produces the two's complement.

Viewing the bitwise operations in base-10 is potentially confusing. Nevertheless, they are useful in specialized situations, especially when one operand is a constant, often called a bitmask. Unfortunately, C++ doesn't have a binary number notation, so programmers typically denote integer constants hexadecimal (or occasionally in octal). 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.

Decimal (base-10) Octal (base-8) Hexadecimal (base-16) Binary (base-2)
0 0 0x0 0000
1 01 0x1 0001
2 02 0x2 0010
3 03 0x3 0011
4 04 0x4 0100
5 05 0x5 0101
6 06 0x6 0110
7 07 0x7 0110
8 010 0x8 1000
9 011 0x9 1001
10 012 0xa 1010
11 013 0xb 1011
12 014 0xc 1100
13 015 0xd 1101
14 016 0xe 1110
15 017 0xf 1111
Forming bit patterns. We can form bit patterns with numerical values in any base, but hexadecimal is particularly convenient, especially for longer patterns. C++ directly supports decimal, octal, and hexadecimal notation. You can recreate this table by beginning each column at zero and counting in the appropriate base, remembering to carry. Decimal numbers are undecorated, while octal and hexadecimal numbers begin with a leading 0 and x, respectively.

Bitmasks

One of the most common uses for bitwise operations is to set, reset, and test bits stored in a multi-bit data structure. Programmers can implement multi-bit data structures in many ways, but they frequently just use integers consisting of 8 to 64 bits, as illustrated in the following examples. We can also implement multi-bit data with arrays (chapter 7), strings (chapter 8), or purpose-built bit-vector classes (chapter 9). Regardless of how we implement them, multi-bit data are often called bit fields, bit sets, bit vectors, bit maps, bit strings, etc.

Programmers use bit fields to represent a variety of settings or conditions compactly. Each bit acts as a switch. A "1" denotes a setting is on, while a "0" means it is off. Programs often use bitwise-OR and bitwise-AND operators in conjunction with constant bit fields, called bitmasks, to switch bits on and off respectively, which corresponds to switching settings on or off.

An image depicting bitmasks as a grate through which each bit must pass. Slots in the grate are formed by 0's or 1'. For bitwise-AND, 1's represent open openings in the grate allowing the bits to pass through unmodified, while 0's switch bits off, always outputting a 0 regardless of the input.
Masks and bitwise-AND. Programmers turn switches or settings off with the Bitwise-AND operation. A "0" in the bitmask forces the corresponding bit in the result to a be "0": 0 & x = 0 (where x may be either "0" or "1"). We can view the "1's" in the mask as openings allowing the original bits to "pass through" unmodified: 1 & x = x.
An image depicting bitmasks as a grate through which each bit must pass. Slots in the grate are formed by 0's or 1'. For bitwise-OR, 0's represent open slots in the grate that allow the bits to pass through unmodified, while 1's always output a 1 regardless of the input value.
Masks and bitwise-OR. Programmers turn switches or settings on with the bitwise-Or operation. A "1" in the bitmask. forces the corresponding bit in the result to a be "1": 1 | x = 1 (where x may be either "0" or "1"). "0's" appearing in the mask allow the original bits to "pass through" unmodified: 0 | x = x.

Input and output operations in a C++ program generally takes place through stream objects (e.g., cin and cout). Programmers control the behaviors of these objects with a set of 1-bit switches or flags. Each bit corresponds to a specific behavior - setting the bit to 0 disables the behavior, and setting it to 1 enables it. Programmers use named bitmasks (i.e., constant values) and bitwise operators to bit settings. Four of the file I/O bitmasks illustrate the concept:

in
Open the file for input (i.e., the program can write to the file)
in = 0x01 = 00000000000000000000000000000001
out
Open the file for output (i.e., the program can read from the file)
out = 0x02 = 00000000000000000000000000000010
app
Append new data to the end of the file (i.e., preserve existing data in the file)
app = 0x08 = 00000000000000000000000000001000
binary
Threat the file contents as binary data (e.g., .gif, .jpg, .wav, .mp3, etc.) files
binary = 0x20 = 00000000000000000000000000100000

To create a value that will switch on all four behaviors, a programmer might write an assignment statement such as:

int mode = in | out | app | binary;

The bitwise-OR operations produce the bit field: 00000000000000000000000000101011, which the programmer could then use to open a file that has the combined behaviors.

The library code that opens the file may look similar to the following:

if (mode & binary != 0)
{
	// then configure the file for reading or writing in binary mode
}
if (mode & app != 0)
{
	// then configure the file for writing in append mode
}
				. . . .

The bitwise-AND operation switches off all the bits except the one corresponding to the binary bitmask. The magnitude (i.e., the exact value) of mode & binary is not significant; what is significant is that the value is not 0. If "binary" had been left out of the assignment statement above (part of the mode calculation), then the expression mode & binary would produce a 0, skipping the code for configuring the file for binary I/O.

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:

11001100 (base 2) << 2 (base 10) is 00110000
Left Shift Operator. Two views of the left shift operator. The shift operation moves an integer's bits to the left. The operation discards the most significant bits, illustrated with strikeout characters, and opens spaces in the least significant positions.

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 0's).

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:

11001100 (base 2) >> 2 (base 10) is 00110011
Right Shift Operator. Two views of the right shift operator without sign extension. The shift operation moves an integer's bits to the right. It discards the least significant bits, illustrated with strikeout characters, and opens spaces in the most significant positions. Three cases produce the illustrated results: (a) the left operand is unsigned, (b) the hardware does not perform sign extension, or (c) the original highest-order bit is a 0.
11001100 (base 2) >> 2 (base 10) is 11110011
Right Shift Operator with sign extension. Two views of the right shift operator with sign extension. The shift operation moves an integer's bits to the right. The shift discards the least significant bits, illustrated with strikeout characters, and opens spaces in the most significant positions. However, how the computer fills the open spaces depends on a combination of circumstances. First, sign extension is a property of the underlying hardware and beyond program control. sign-extend hardware copies the highest-order bit into the opened positions. So, the second circumstance is the value of the highest-order bit, highlighted with orange, when the shift operation occurs. So, the program produces the illustrated result only when the left operand is signed, the hardware performs sign extension, and the highest-order bit is 1.

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.

Operation With Assignment Meaning
V &= EV = V & E
V |= EV = V | E
V ^= EV = V ^ E
V >>= IV = V >> I
V <<= IV = V << I
Operation with assignment with bitwise operators. B is a Boolean variable, E is a Boolean-valued expression, and I is an integer-valued expression (often a constant or variable).