bitset
sTable 17.2 (overleaf) lists the constructors for bitset
. The bitset
class is a class template that, like the array
class, has a fixed size (§ 9.2.4, p. 336). When we define a bitset
, we say how many bits the bitset
will contain:
bitset<32> bitvec(1U); // 32 bits; low-order bit is 1, remaining bits are 0
The size must be a constant expression (§ 2.4.4, p. 65). This statement defines bitvec
as a bitset
that holds 32
bits. Just as with the elements of a vector
, the bits in a bitset
are not named. Instead, we refer to them positionally. The bits are numbered starting at 0
. Thus, bitvec
has bits numbered 0
through 31
. The bits starting at 0
are referred to as the low-order bits, and those ending at 31
are referred to as high-order bits.
bitset
from an unsigned
ValueWhen we use an integral value as an initializer for a bitset
, that value is converted to unsigned long long
and is treated as a bit pattern. The bits in the bitset
are a copy of that pattern. If the size of the bitset
is greater than the number of bits in an unsigned long long
, then the remaining high-order bits are set to zero. If the size of the bitset
is less than that number of bits, then only the low-order bits from the given value are used; the high-order bits beyond the size of the bitset
object are discarded:
// bitvec1 is smaller than the initializer; high-order bits from the initializer are discarded
bitset<13> bitvec1 (0xbeef); // bits are 1111011101111
// bitvec2 is larger than the initializer; high-order bits in bitvec2 are set to zero
bitset<20> bitvec2(0xbeef); // bits are 00001011111011101111
// on machines with 64-bit long long 0ULL is 64 bits of 0, so ~0ULL is 64 ones
bitset<128> bitvec3(~0ULL); // bits 0 ... 63 are one; 63 ... 127 are zero
bitset
from a string
We can initialize a bitset
from either a string
or a pointer to an element in a character array. In either case, the characters represent the bit pattern directly. As usual, when we use strings to represent numbers, the characters with the lowest indices in the string correspond to the high-order bits, and vice versa:
bitset<32> bitvec4("1100"); // bits 2 and 3 are 1, all others are 0
If the string
contains fewer characters than the size of the bitset
, the high-order bits are set to zero.
The indexing conventions of string
s and bitset
s are inversely related: The character in the string
with the highest subscript (the rightmost character) is used to initialize the low-order bit in the bitset
(the bit with subscript 0). When you initialize a bitset
from a string
, it is essential to remember this difference.
We need not use the entire string
as the initial value for the bitset
. Instead, we can use a substring as the initializer:
string str("1111111000000011001101");
bitset<32> bitvec5(str, 5, 4); // four bits starting at str[5], 1100
bitset<32> bitvec6(str, str.size()-4); // use last four characters
Here bitvec5
is initialized by the substring in str
starting at str[5]
and continuing for four positions. As usual, the right-most character of the substring represents the lowest-order bit. Thus, bitvec5
is initialized with bit positions 3 through 0 set to 1100
and the remaining bits set to 0
. The initializer for bitvec6
passes a string
and a starting point, so bitvec6
is initialized from the characters in str
starting four from the end of str
. The remainder of the bits in bitvec6
are initialized to zero. We can view these initializations as