Bitset Operations and Access

A bitset is a fixed-size collection of bits. Before you can use one, you need to give it starting values, and C++ offers more than one way to do that. The source material for this lesson states that a bitset can be initialized with an integer or a string. Both forms use the same brace-based declaration style, so the main thing to learn is which kind of value goes inside the braces and what that value means for the bits that end up stored.

The lesson follows a simple rhythm: work out what the code should produce, then trace the mechanism that actually produces the bits. Keep the prediction above in mind, because the next sections show exactly how a string and an integer each become a bit pattern.

A bitset declaration names its size in angle brackets and gives the initial value in braces. The general pattern is bitset<N> bs {value};, where N is the number of bits and value is the initial value you supply. The angle-bracket part controls how many bits the bitset has. The variable name, here bs, is the name you use to refer to the bitset later. The brace-enclosed value controls the starting bits.

The size N is part of the type, so bitset<9> and bitset<8> are different types. A bitset declared with N = 9 always has exactly nine bits, whatever value you pass in. The value inside the braces decides which starting bits those nine positions receive. The source material notes that a bitset can be initialized with different constructors, and that the kind of argument you choose decides which constructor is used.

When the value inside the braces is a string literal, the bitset is built from the characters of that string. The string is enclosed in double quotes, which marks it as text rather than a number. In the source example, bitset<9> bs1 {"110001111"}; passes a nine-character string made of 0 and 1 characters. Nine characters fill nine bits, so every character has a bit position to land in.

When the value inside the braces is an integer, the bitset is built from that number. The source example bitset<9> bs2 {399}; uses an integer literal with no quotes. There is no separate string conversion step in the code, because the value is already a number. The integer form is useful when your starting value is already a number, such as a computed result or a constant.

The expansion above shows where the bit pattern comes from. The powers 2^{^8} and 2^{^7} contribute to bits 8 and 7, and the powers 2^{^3}, 2^{^2}, 2^{^1}, and 2^{^0} contribute to bits 3, 2, 1, and 0. The remaining bits 6, 5, and 4 are 0. Reading those nine positions from left to right gives 110001111, which is the same pattern as the string in the previous section.

The size N is fixed by the angle-bracket value, so the bitset always has exactly that many bits. What happens when the starting value has a different number of bits than N is an important check. If the value has fewer bits than N, the bits that the value does not supply are zero. For example, the four-character string "1011" placed in an eight-bit bitset fills the four low positions, and the four high positions stay 0. If the integer has more significant bits than N can hold, the bits beyond position N minus 1 are not kept, so bitset<8> {399} keeps only the low eight bits of 399.

Because N is part of the declaration, a mismatch between the value and N is a common source of unexpected bit patterns. When you check an initialization, compare the number of bits the value actually supplies with the N you declared.

Two differently initialized bitsets hold the same bit pattern when every index has the same value in both. You can check this position by position: write down the bits of each bitset from bit N minus 1 down to bit 0, then compare the two lists. If every position matches, the bitsets hold the same pattern, even though the initial values were written in different forms.

When two declarations that should match do not, the mismatch points to one of three places: the value you passed, the size you declared, or the constructor form you chose. Check each of these in turn.