---
name: "std::bitset"
section: "3"
platform: "linux"
package: "gcc"
version: "16.2.1+r23+gd564253eb6c8-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/std::bitset"
---

# std::bitset(3)

The bitset class represents a fixed-size sequence of bits.

## NAME

std::bitset\< \_Nb \> - The bitset class represents a *fixed-size* sequence of bits.

## SYNOPSIS

\#include \<bitset\>

Inherits **std::\_Base\_bitset\<((\_Nb)/(\_\_CHAR\_BIT\_\_ \*\_\_SIZEOF\_LONG\_\_)+((\_Nb) %(\_\_CHAR\_BIT\_\_ \*\_\_SIZEOF\_LONG\_\_)==0 ? 0 :1))\>**.

### Classes

class **reference**\

### Public Member Functions

constexpr **bitset** () noexcept\
 All bits set to zero.  template\<typename \_CharT, typename = \_Require\<is\_trivially\_copyable\<\_CharT\>,				   is\_standard\_layout\<\_CharT\>,				   is\_trivially\_default\_constructible\<\_CharT\>,				   \_\_not\_\<is\_array\<\_CharT\>\>\>\> constexpr **bitset** (const \_CharT \*\_\_str, typename \_\_bitset::\_\_string\< \_CharT \>**::size\_type** \_\_n=\_\_bitset::\_\_string\< \_CharT \>::npos, \_CharT \_\_zero=\_CharT('0'), \_CharT \_\_one=\_CharT('1'))\
 template\<class \_CharT, class \_Traits, class \_Alloc\> constexpr **bitset** (const **std::basic\_string**\< \_CharT, \_Traits, \_Alloc \> &\_\_s, size\_t \_\_position, size\_t \_\_n)\
 template\<class \_CharT, class \_Traits, class \_Alloc\> constexpr **bitset** (const **std::basic\_string**\< \_CharT, \_Traits, \_Alloc \> &\_\_s, size\_t \_\_position, size\_t \_\_n, \_CharT \_\_zero, \_CharT \_\_one=\_CharT('1'))\
 template\<class \_CharT, class \_Traits, class \_Alloc\> constexpr **bitset** (const **std::basic\_string**\< \_CharT, \_Traits, \_Alloc \> &\_\_s, size\_t \_\_position=0)\
 constexpr **bitset** (unsigned long long \_\_val) noexcept\
 Initial bits bitwise-copied from a single word (others set to zero).  constexpr size\_t **\_Find\_first** () const noexcept\
 Finds the index of the first *on"*bit. constexpr size\_t **\_Find\_next** (size\_t \_\_prev) const noexcept\
 Finds the index of the next *on"*bit*after*prev. constexpr bool **all** () const noexcept\
 Tests whether all the bits are on.  constexpr bool **any** () const noexcept\
 Tests whether any of the bits are on.  constexpr size\_t **count** () const noexcept\
 Returns the number of bits which are set.  constexpr **bitset**\< \_Nb \> & **flip** () noexcept\
 Toggles every bit to its opposite value.  constexpr **bitset**\< \_Nb \> & **flip** (size\_t \_\_position)\
 Toggles a given bit to its opposite value.  constexpr bool **none** () const noexcept\
 Tests whether any of the bits are on.  constexpr **bitset**\< \_Nb \> **operator~** () const noexcept\
 See the no-argument flip().  constexpr **bitset**\< \_Nb \> & **reset** () noexcept\
 Sets every bit to false.  constexpr **bitset**\< \_Nb \> & **reset** (size\_t \_\_position)\
 Sets a given bit to false.  constexpr **bitset**\< \_Nb \> & **set** () noexcept\
 Sets every bit to true.  constexpr **bitset**\< \_Nb \> & **set** (size\_t \_\_position, bool \_\_val=true)\
 Sets a given bit to a particular value.  constexpr size\_t **size** () const noexcept\
 Returns the total number of bits.  constexpr bool **test** (size\_t \_\_position) const\
 Tests the value of a bit.  constexpr **std::basic\_string**\< char, **std::char\_traits**\< char \>, **std::allocator**\< char \> \> **to\_string** () const\
 template\<class \_CharT\> constexpr **std::basic\_string**\< \_CharT, **std::char\_traits**\< \_CharT \>, **std::allocator**\< \_CharT \> \> **to\_string** () const\
 template\<class \_CharT, class \_Traits\> constexpr **std::basic\_string**\< \_CharT, \_Traits, **std::allocator**\< \_CharT \> \> **to\_string** () const\
 template\<class \_CharT, class \_Traits, class \_Alloc\> constexpr **std::basic\_string**\< \_CharT, \_Traits, \_Alloc \> **to\_string** () const\
 Returns a character interpretation of the bitset.  template\<class \_CharT\> constexpr **std::basic\_string**\< \_CharT, **std::char\_traits**\< \_CharT \>, **std::allocator**\< \_CharT \> \> **to\_string** (\_CharT \_\_zero, \_CharT \_\_one=\_CharT('1')) const\
 template\<class \_CharT, class \_Traits\> constexpr **std::basic\_string**\< \_CharT, \_Traits, **std::allocator**\< \_CharT \> \> **to\_string** (\_CharT \_\_zero, \_CharT \_\_one=\_CharT('1')) const\
 template\<class \_CharT, class \_Traits, class \_Alloc\> constexpr **std::basic\_string**\< \_CharT, \_Traits, \_Alloc \> **to\_string** (\_CharT \_\_zero, \_CharT \_\_one=\_CharT('1')) const\
 constexpr **std::basic\_string**\< char, **std::char\_traits**\< char \>, **std::allocator**\< char \> \> **to\_string** (char \_\_zero, char \_\_one='1') const\
 constexpr unsigned long long **to\_ullong** () const\
 constexpr unsigned long **to\_ulong** () const\
 Returns a numerical interpretation of the bitset.

constexpr **bitset**\< \_Nb \> & **operator&=** (const **bitset**\< \_Nb \> &\_\_rhs) noexcept\
 constexpr **bitset**\< \_Nb \> & **operator\|=** (const **bitset**\< \_Nb \> &\_\_rhs) noexcept\
 constexpr **bitset**\< \_Nb \> & **operator^=** (const **bitset**\< \_Nb \> &\_\_rhs) noexcept\

constexpr **bitset**\< \_Nb \> & **operator\<\<=** (size\_t \_\_position) noexcept\
 constexpr **bitset**\< \_Nb \> & **operator\>\>=** (size\_t \_\_position) noexcept\

constexpr **bitset**\< \_Nb \> & **\_Unchecked\_set** (size\_t \_\_pos) noexcept\
 constexpr **bitset**\< \_Nb \> & **\_Unchecked\_set** (size\_t \_\_pos, int \_\_val) noexcept\
 constexpr **bitset**\< \_Nb \> & **\_Unchecked\_reset** (size\_t \_\_pos) noexcept\
 constexpr **bitset**\< \_Nb \> & **\_Unchecked\_flip** (size\_t \_\_pos) noexcept\
 constexpr bool **\_Unchecked\_test** (size\_t \_\_pos) const noexcept\

constexpr **reference** **operator\[\]** (size\_t \_\_position)\
 Array-indexing support.  constexpr bool **operator\[\]** (size\_t \_\_position) const\
 Array-indexing support.

constexpr bool **operator==** (const **bitset**\< \_Nb \> &\_\_rhs) const noexcept\
 These comparisons for equality/inequality are, well, *bitwise*.

constexpr **bitset**\< \_Nb \> **operator\<\<** (size\_t \_\_position) const noexcept\
 Self-explanatory.  constexpr **bitset**\< \_Nb \> **operator\>\>** (size\_t \_\_position) const noexcept\
 Self-explanatory.

### Friends

template\<class \_CharT, class \_Traits, size\_t \_Nb2\> **std::basic\_ostream**\< \_CharT, \_Traits \> & **operator\<\<** (**std::basic\_ostream**\< \_CharT, \_Traits \> &, const **bitset**\< \_Nb2 \> &)\
 template\<class \_CharT, class \_Traits, size\_t \_Nb2\> **std::basic\_istream**\< \_CharT, \_Traits \> & **operator\>\>** (**std::basic\_istream**\< \_CharT, \_Traits \> &, **bitset**\< \_Nb2 \> &)\
 class **reference**\
 struct **std::hash\< bitset \>**\

## Detailed Description

### template\<size\_t \_Nb\>

class std::bitset\< \_Nb \>"The bitset class represents a *fixed-size* sequence of bits.

(Note that bitset does *not* meet the formal requirements of a container. Mainly, it lacks iterators.)

The template argument, Nb, may be any non-negative number, specifying the number of bits (e.g., "0", "12", "1024\*1024").

In the general unoptimized case, storage is allocated in word-sized blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B words will be used for storage. B - NbB bits are unused. (They are the high-order bits in the highest word.) It is a class invariant that those unused bits are always zero.

If you think of bitset as *a simple array of bits*, be aware that your mental picture is reversed: a bitset behaves the same way as bits in integers do, with the bit at index 0 in the *least significant / right-hand* position, and the bit at index Nb-1 in the *most significant / left-hand* position. Thus, unlike other containers, a bitset's index *counts from right to left*, to put it very loosely.

This behavior is preserved when translating to and from strings. For example, the first line of the following program probably prints *b('a') is 0001100001* on a modern ASCII system.

```
#include <bitset>
#include <iostream>
#include <sstream>
using namespace std;
int main()
{
    long         a = 'a';
    bitset<10>   b(a);
    cout << "b('a') is " << b << endl;
    ostringstream s;
    s << b;
    string  str = s.str();
    cout << "index 3 in the string is " << str[3] << " but\n"
         << "index 3 in the bitset is " << b[3] << endl;
}
```

Also see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext\_containers.html for a description of extensions.

Most of the actual code isn't contained in bitset\<\> itself, but in the base class \_Base\_bitset. The base class works with whole words, not with individual bits. This allows us to specialize \_Base\_bitset for the important special case where the bitset is only a single word.

Extra confusion can result due to the fact that the storage for \_Base\_bitset *is* a regular array, and is indexed as such. This is carefully encapsulated.

## Constructor & Destructor Documentation

### template\<size\_t \_Nb\> std::bitset\< \_Nb \>::bitset () \[inline\], \[constexpr\], \[noexcept\]

All bits set to zero.

Referenced by **operator&=()**, **operator\<\<()**, **operator\<\<=()**, **operator==()**, **operator\>\>()**, **operator^=()**, **operator\|=()**, and **operator~()**.

### template\<size\_t \_Nb\> std::bitset\< \_Nb \>::bitset (unsigned long long \_\_val) \[inline\], \[constexpr\], \[noexcept\]

Initial bits bitwise-copied from a single word (others set to zero).

### template\<size\_t \_Nb\> template\<class \_CharT, class \_Traits, class \_Alloc\> std::bitset\< \_Nb \>::bitset (const std::basic\_string\< \_CharT, \_Traits, \_Alloc \> & \_\_s, size\_t \_\_position = 0) \[inline\], \[explicit\], \[constexpr\]

Use a subset of a string.

**Parameters**

*\_\_s* A string of 0 and 1 characters. \
 *\_\_position* Index of the first character in \_\_s to use; defaults to zero.

**Exceptions**

**std::out\_of\_range If** \_\_position \> \_\_s.size()**.** \
 **std::invalid\_argument If a character appears in the string which is neither** 0 **nor** 1**.**

**References std::basic\_string\< \_CharT, \_Traits, \_Alloc \>::npos.**

### template\<size\_t \_Nb\> template\<class \_CharT, class \_Traits, class \_Alloc\> std::bitset\< \_Nb \>::bitset (const std::basic\_string\< \_CharT, \_Traits, \_Alloc \> & \_\_s, size\_t \_\_position, size\_t \_\_n) \[inline\], \[constexpr\]

**Use a subset of a string.**

**Parameters**

*\_\_s* **A string of** 0 **and** 1 **characters.** \
 *\_\_position* **Index of the first character in** \_\_s **to use.** \
 *\_\_n* **The number of characters to copy.**

**Exceptions**

**std::out\_of\_range If** \_\_position \> \_\_s.size()**.** \
 **std::invalid\_argument If a character appears in the string which is neither** 0 **nor** 1**.**

### template\<size\_t \_Nb\> template\<typename \_CharT, typename = \_Require\<is\_trivially\_copyable\<\_CharT\>, is\_standard\_layout\<\_CharT\>, is\_trivially\_default\_constructible\<\_CharT\>, \_\_not\_\<is\_array\<\_CharT\>\>\>\> std::bitset\< \_Nb \>::bitset (const \_CharT \* \_\_str, typename \_\_bitset\< \_Nb \>::\_\_string\< \_CharT \>::size\_type \_\_n = \_\_bitset\< \_Nb \>::\_\_string\<\_CharT\>::npos, \_CharT \_\_zero = \_CharT('0'), \_CharT \_\_one = \_CharT('1')) \[inline\], \[explicit\], \[constexpr\]

**Construct from a character array.**

**Parameters**

*\_\_str* **An array of characters** \_\_zero **and** \_\_one**.** \
 *\_\_n* **The number of characters to use.** \
 *\_\_zero* **The character corresponding to the value 0.** \
 *\_\_one* **The character corresponding to the value 1.**

**Exceptions**

**std::invalid\_argument If a character appears in the string which is neither** \_\_zero **nor** \_\_one**.**

**References std::basic\_string\< \_CharT \>::npos.**

## Member Function Documentation

### template\<size\_t \_Nb\> bool std::bitset\< \_Nb \>::all () const \[inline\], \[constexpr\], \[noexcept\]

**Tests whether all the bits are on.**

**Returns**

**True if all the bits are set.**

### template\<size\_t \_Nb\> bool std::bitset\< \_Nb \>::any () const \[inline\], \[constexpr\], \[noexcept\]

**Tests whether any of the bits are on.**

**Returns**

**True if at least one bit is set.**

### template\<size\_t \_Nb\> size\_t std::bitset\< \_Nb \>::count () const \[inline\], \[constexpr\], \[noexcept\]

**Returns the number of bits which are set.**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::flip () \[inline\], \[constexpr\], \[noexcept\]

**Toggles every bit to its opposite value.**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::flip (size\_t \_\_position) \[inline\], \[constexpr\]

**Toggles a given bit to its opposite value.**

**Parameters**

*\_\_position* **The index of the bit.**

**Exceptions**

**std::out\_of\_range If** *pos* **is bigger the size of the set.**

**References \_Unchecked\_flip().**

### template\<size\_t \_Nb\> bool std::bitset\< \_Nb \>::none () const \[inline\], \[constexpr\], \[noexcept\]

**Tests whether any of the bits are on.**

**Returns**

**True if none of the bits are set.**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::operator&= (const bitset\< \_Nb \> & \_\_rhs) \[inline\], \[constexpr\], \[noexcept\]

**Operations on bitsets.**

**Parameters**

*\_\_rhs* **A same-sized bitset.**

**These should be self-explanatory.**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> std::bitset\< \_Nb \>::operator\<\< (size\_t \_\_position) const \[inline\], \[constexpr\], \[noexcept\]

**Self-explanatory.**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::operator\<\<= (size\_t \_\_position) \[inline\], \[constexpr\], \[noexcept\]

**Operations on bitsets.**

**Parameters**

*\_\_position* **The number of places to shift.**

**These should be self-explanatory.**

**References bitset(), and operator\<\<=().**

**Referenced by operator\<\<=().**

### template\<size\_t \_Nb\> bool std::bitset\< \_Nb \>::operator== (const bitset\< \_Nb \> & \_\_rhs) const \[inline\], \[constexpr\], \[noexcept\]

**These comparisons for equality/inequality are, well,** *bitwise***.**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> std::bitset\< \_Nb \>::operator\>\> (size\_t \_\_position) const \[inline\], \[constexpr\], \[noexcept\]

**Self-explanatory.**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::operator\>\>= (size\_t \_\_position) \[inline\], \[constexpr\], \[noexcept\]

**Operations on bitsets.**

**Parameters**

*\_\_position* **The number of places to shift.**

**These should be self-explanatory.**

### template\<size\_t \_Nb\> reference std::bitset\< \_Nb \>::operator\[\] (size\_t \_\_position) \[inline\], \[constexpr\]

**Array-indexing support.**

**Parameters**

*\_\_position* **Index into the bitset.**

**Returns**

**A bool for a** *const bitset***. For non-const bitsets, an instance of the reference proxy class.**

**Note**

**These operators do no range checking and throw no exceptions, as required by DR 11 to the standard.**

**\_GLIBCXX\_RESOLVE\_LIB\_DEFECTS Note that this implementation already resolves DR 11 (items 1 and 2), but does not do the range-checking required by that DR's resolution. -pme The DR has since been changed: range-checking is a precondition (users' responsibility), and these functions must not throw. -pme**

### template\<size\_t \_Nb\> bool std::bitset\< \_Nb \>::operator\[\] (size\_t \_\_position) const \[inline\], \[constexpr\]

**Array-indexing support.**

**Parameters**

*\_\_position* **Index into the bitset.**

**Returns**

**A bool for a** *const bitset***. For non-const bitsets, an instance of the reference proxy class.**

**Note**

**These operators do no range checking and throw no exceptions, as required by DR 11 to the standard.**

**\_GLIBCXX\_RESOLVE\_LIB\_DEFECTS Note that this implementation already resolves DR 11 (items 1 and 2), but does not do the range-checking required by that DR's resolution. -pme The DR has since been changed: range-checking is a precondition (users' responsibility), and these functions must not throw. -pme**

**References \_Unchecked\_test().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::operator^= (const bitset\< \_Nb \> & \_\_rhs) \[inline\], \[constexpr\], \[noexcept\]

**Operations on bitsets.**

**Parameters**

*\_\_rhs* **A same-sized bitset.**

**These should be self-explanatory.**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::operator\|= (const bitset\< \_Nb \> & \_\_rhs) \[inline\], \[constexpr\], \[noexcept\]

**Operations on bitsets.**

**Parameters**

*\_\_rhs* **A same-sized bitset.**

**These should be self-explanatory.**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> std::bitset\< \_Nb \>::operator~ () const \[inline\], \[constexpr\], \[noexcept\]

**See the no-argument flip().**

**References bitset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::reset () \[inline\], \[constexpr\], \[noexcept\]

**Sets every bit to false.**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::reset (size\_t \_\_position) \[inline\], \[constexpr\]

**Sets a given bit to false.**

**Parameters**

*\_\_position* **The index of the bit.**

**Exceptions**

**std::out\_of\_range If** *pos* **is bigger the size of the set.**

**Same as writing** set(pos,false)**.**

**References \_Unchecked\_reset().**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::set () \[inline\], \[constexpr\], \[noexcept\]

**Sets every bit to true.**

### template\<size\_t \_Nb\> bitset\< \_Nb \> & std::bitset\< \_Nb \>::set (size\_t \_\_position, bool \_\_val = true) \[inline\], \[constexpr\]

**Sets a given bit to a particular value.**

**Parameters**

*\_\_position* **The index of the bit.** \
 *\_\_val* **Either true or false, defaults to true.**

**Exceptions**

**std::out\_of\_range If** *pos* **is bigger the size of the set.**

**References \_Unchecked\_set().**

### template\<size\_t \_Nb\> size\_t std::bitset\< \_Nb \>::size () const \[inline\], \[constexpr\], \[noexcept\]

**Returns the total number of bits.**

### template\<size\_t \_Nb\> bool std::bitset\< \_Nb \>::test (size\_t \_\_position) const \[inline\], \[constexpr\]

**Tests the value of a bit.**

**Parameters**

*\_\_position* **The index of a bit.**

**Returns**

**The value at** *pos***.**

**Exceptions**

**std::out\_of\_range If** *pos* **is bigger the size of the set.**

**References \_Unchecked\_test().**

### template\<size\_t \_Nb\> template\<class \_CharT, class \_Traits, class \_Alloc\> std::basic\_string\< \_CharT, \_Traits, \_Alloc \> std::bitset\< \_Nb \>::to\_string () const \[inline\], \[constexpr\]

**Returns a character interpretation of the bitset.**

**Returns**

**The string equivalent of the bits.**

**Note the ordering of the bits: decreasing character positions correspond to increasing bit positions (see the main class notes for an example).**

### template\<size\_t \_Nb\> unsigned long std::bitset\< \_Nb \>::to\_ulong () const \[inline\], \[constexpr\]

**Returns a numerical interpretation of the bitset.**

**Returns**

**The integral equivalent of the bits.**

**Exceptions**

**std::overflow\_error If there are too many bits to be represented in an** unsigned long**.**

## Author

**Generated automatically by Doxygen for libstdc++ from the source code.**