C++ For Mathematicians (2006) [eng]

12.5.2 Bit operations

C++ provides six operators for working with the binary representation of integers.

Bitwise and For integer variables x and y, the expression x&y is the bitwise and of x and y. That is, the kth bit of x&y is 1 if and only if the kth bits of both x and y are 1. Here is an example.

The bitwise and operation & should not be confused with the Boolean and operation &&. You should use && only with bool values.

Bitwise or Similar to bitwise and, the operation x|y gives the bitwise or of x and y. That is, the kth bit of x|y is 0 if and only if the kth bits of both x and y are 0. Here is an example.

The bitwise or operation | should not be confused with the Boolean or operation ||. You should use || only with bool values.

Exclusive or The expression xˆy gives the bitwise exclusive or of x and y. That is, the kth bit of x|y is 0 if and only if exactly one of the kth bits of both x and y is 1. Here is an example.

Bitwise not The expression ˜x interchanges 1s and 0s in x. That is, the kth bit of ˜x is 1 if and only if the kth bit of x is 0. Here is an example.

The bitwise not operation ˜ should not be confused with the Boolean not operation !. You should use ! only with bool values.

Left shift The expression x<<n (where n is a nonnegative integer) shifts the bits of x to the left n steps. The right-hand side of the result is filled with 0s. Any bits in the highest n positions are lost. Here is an example.

The symbol << is the same one we use for writing to the console, as in the statement cout << x << endl;. C++ is able to distinguish between these cases by inspecting the types of objects on either side of the << symbol.

The expression x<<n is equivalent to multiplying x by 2n (unless bits are lost at the left).

Right shift The expression x>>n (where n is a nonnegative integer) shifts the bits of x to the right n places. Bits in the lower n places are lost. The vacated positions on the left are filled in with 0s or with 1s depending on the situation:

•If x is an unsigned integer type, 0s are inserted at the left.

•If x is a signed integer type and x is nonnegative, 0s are inserted at the left.

•If x is a negative integer, then 1s are inserted at the left. Here are some examples.

The right shift operator >> uses the same symbol we use for keyboard input, for example, cin >> x;. As with left shift, C++ distinguishes these cases by inspecting the types of the objects on either side of the >> symbol.

All six of these operators can be combined with the assignment operator, =. The expression x &= y is equivalent to x = (x&y), and so on.

Bit operations can be combined to perform operations that would be difficult with standard mathematical operators. For example, suppose we want to set the kth bit of x to 1; the following code does the trick: x |= (1<<k);. If we want to set that bit to zero, we do this: x &= ˜(1<<k);.

12.5.3 The bitset class template

Using integer types to represent a list of binary values is efficient, but presents two drawbacks. First, this technique is limited to the size of an integer on your computer; if you want a list of, say, 200 bits, there is no integer type with that capacity. Second, using bit manipulation can result in obfuscated code. Human beings find statements such as x&=˜(1<<k); difficult to understand. (The statement sets the kth bit of x to zero.) If your problem requires high speed for short lists of bits, then bit manipulation of integer types may be your best option. However, there are two other choices of which you should be aware.

The first option, also discussed in Section 8.4, is to use vector<bool> variables; these are adjustable arrays of true/false values. To set the kth bit of such an

array equal to zero (false), we use the considerably clearer statement x[k]=0; or x[k]=false;. Variables of type vector<bool> use memory efficiently, can be easily resized, and provide convenient access to their elements. However, the bitwise operations (such as &, ˜, >>, etc.) cannot be used with variables of type vector<bool>. If one wished to interchange all the 0s and 1s held in x, the statement x=˜x; does not work. Instead, one would need to write a for loop to change the bits one by one:

for (int k=0; k<x.size(); k++) { x[k] = !x[k];

}

The second option is to use a bitset. A bitset object is a fixed size repository of bits. To use variables of type bitset, start with #include <bitset> and declare variables like this:

bitset<100> x;

This sets up x as a list of 100 bits. Notice that bitset is a template but its argument is a number, not a type; we explain how to do this later in this section. The important point is that this number is a constant, not a variable. The following code is illegal.

int n;

cout << "Enter number of bits --> "; cin >> n;

bitset<n> x; // illegal constructor, n is not a constant

The size of the bitset must be declared when you write your program, not while the program is running.

Here is a list of the various methods and operators available for bitsets.

• Constructors. The standard constructor has the form

bitset<number> var;

where number is a specific positive integer. This may be a const int defined earlier in the code, or an explicitly typed value, such as 100. The variable var holds number bits, and at this point these are all 0s.

One may construct from an unsigned long integer value. For example,

bitset<20> x(39);

sets x to 00000000000000100111 (the binary representation of 39).

One may also construct from a C++ string object (these are discussed later in Section 14.2). The constructor

bitset<20> x(string("10110001"));

sets x to 00000000000010110001. The type string is required; don’t use bitset<20> x("10110001"));.

Finally, a copy constructor is available:

bitset<20> y(x);

makes y a copy of x. Note that x must also be a bitset<20> and may not be a bitset of any other size.

•Inspection methods. These are methods one can use to learn information about the bits held in a bitset. Suppose x is a bitset<100>:

–x.size() returns the number of bits that x holds (in this example, 100).

–x.any() returns true if at least one bit in x is a 1.

–x.none() returns true if all of the bits are 0.

–x.count() returns the number of 1s in x.

–x.test(k) returns true if the kth bit of x is a 1. Of course, k must be at least 0 and less than x.size().

•Bit manipulation methods. The following methods may be used to alter the value held in the bits of a bitset. Suppose x is a bitset<100>:

–x.set() sets all of x’s bits to 1.

–x.set(k) sets the kth bit to 1.

–x.set(k,b) sets the kth bit base on the value held in the integer variable b. If b is zero, the kth bit of x is set to 0; otherwise it is set to 1.

–x.reset() sets all of x’s bits to 0.

–x.reset(k) sets bit k to 0.

–x.flip() swaps 0 and 1 values in every position of x. For example, suppose x holds 1110001110; after the statement x.flip();, it now holds 0001110001.

–x.flip(k) flips the kth bit of x.

•Comparison operators. If x and y are both bitsets of the same size, then we may compare them with the usual expressions x==y and x!=y.

•Bit operators. The standard bitwise operators (&, |, ˆ, ˜, <<, >>) and their assignment variants (&=, |=, ˆ=, ˜=, <<=, >>=) may be used on a pair of bitsets of the same size.

•Array style access. In addition to the methods described above, individual elements of a bitset may be accessed using square brackets. The expression x[k] is the kth element of x. The expression x[k] may appear on the right or the left of an assignment statement such as x[4]=˜x[10];.

In addition, the expression x[5].flip() is equivalent to x.flip(5); both of these toggle the fifth bit of x.

where the data and methods in MyTemplateClass may refer to variables of type T. Variables are declared with statements such as this.

MyTemplateClass<double> x;

However, the template parameters (the arguments between < and > delimiters) need not be classes. For example, we could create a class template such as this:

template <long N> AnotherClass {

.....

};

The parameter N may appear in the data and methods of AnotherClass wherever a constant long integer might rightly go. For example, AnotherClass might include a data member that is an array declared like this:

private:

double coordinates[N];

Note that AnotherClass<10> and AnotherClass<11> are different classes (although based on the same template).

Template classes may have multiple parameters that may be classes or specific values as in this example:

template <class T, double X, int N, class S> ComplicatedClass {

.....

};

A declaration based on this template would look like this:

ComplicatedClass<int, -3.5, 17, double> x;

12.6Exercises

12.1Exercise 7.3 (page 126) asks you to create a procedure to find the median of a list of real (double) numbers. Make a new version that can handle numbers of any type by using a template. The procedure should not modify the array.

12.2Exercise 11.5 (page 233) asks you to create the class SmartArray that allows arbitrary indexing (e.g., a −1 index returns the last element of the array). In that problem, a SmartArray contains long integers. Create a new version of SmartArray that can hold values of any given type. For example, to declare a SmartArray to hold 20 double values, you would type this:

SmartArray<double> X(20);

12.3Create a derivative procedure that finds the derivative of a Polynomial.

12.4Create a root-finding procedure for polynomials based on Newton’s method. Given a polynomial p and initial guess x0, the procedure should solve p(x) = 0 using the iteration

p(xk) xk+1 = xk − p0(xk) .

How many iterations should be performed? You may either let the user set the number of iterations or a desired tolerance ε so that |p(x)| < ε.

Be sure to address the following issues.

•The polynomial may be either real or complex.

•The initial x0 may be either real or complex.

•The roots might not be simple (i.e., the roots might have multiplicity greater than 1).

12.5The pair class template (defined in the utility header) is a handy mechanism for creating ordered pairs; see Section 8.5. Using pair as an inspiration, create a triple class template that represents an ordered three-tuple (x,y,z) where the three elements may be of any type (including different types from each other). Make the data fields public and name them first, second, and third.

Remember to define an operator< that orders the triples lexicographically.

In addition, provide a make_triple procedure procedure that is analogous to make_pair.

12.6Create a RationalFunction class template to represent rational functions. [A rational function is a quotient of two polynomials, p(x)/q(x).] The coeffi-

cients may be real, complex, or from Zp for some prime p. Include the basic operations +, −, ×, ÷.

12.7Write a program to print out all subsets of the set {1,2,...,n}. Do this with an integer variable that steps from 0 to 2n −1 and convert that value into a set.