`bitset`-Klasse

Artikel
10/12/2023

Beschreibt einen Typ von Objekt, das eine Sequenz speichert, die aus einer festen Anzahl von Bits besteht, die eine kompakte Möglichkeit bieten, Flags für eine Menge von Elementen oder Bedingungen bereitzustellen. Die bitset Klasse unterstützt Vorgänge für Objekte vom Typ Bitset, die eine Auflistung von Bits enthalten, und bieten konstanten Zeitzugriff auf die einzelnen Bits.

Syntax

template <size_t N>
class bitset

Parameter

N
Gibt die Anzahl der Bits im bitset Objekt mit einer Nichtzero-Ganzzahl des Typs size_t an, die zur Kompilierungszeit bekannt sein muss.

Hinweise

Im Gegensatz zur ähnlichen vector<bool> Klasse verfügt die bitset Klasse nicht über Iteratoren und ist kein C++-Standardbibliothekscontainer. Es unterscheidet sich auch von vector<bool> einer bestimmten Größe, die zur Kompilierungszeit festgelegt ist, gemäß der Größe, die durch den Vorlagenparameter N angegeben wird, wenn dies bitset<N> deklariert wird.

Ein Bit ist festgelegt, wenn es den Wert 1 hat, und zurückgesetzt, wenn es den Wert 0 hat. Ein Bit zu spiegeln oder umzukehren bedeutet, dass sein Wert von 1 in 0 oder von 0 in 1 geändert wird. Die N Bits in a bitset werden von ganzzahligen Werten von 0 bis N -1 indiziert, wobei 0 die erste Bitposition indiziert und N - 1 die letzte Bitposition.

Member

Konstruktoren

Name	Beschreibung
`bitset`	Erstellt ein `bitset<N>`-Objekt und initialisiert die Bits mit 0 (Null), mit einem angegebenen Wert oder mit Werten, die aus Zeichen einer Zeichenfolge ermittelt wurden.

TypeDefs

Name	Beschreibung
`element_type`	Ein Typ, der gleichbedeutend mit dem Datentyp `bool` ist und verwendet werden kann, um auf Elementbits in einem `bitset`-Objekt zu verweisen.

Functions

Name	Beschreibung
`all`	Testet alle Bits in diesem Bereich`bitset`, um zu bestimmen, ob sie alle auf ".`true`
`any`	Die Memberfunktion überprüft, ob jedes Bit in der Sequenz auf 1 festgelegt ist.
`count`	Die Memberfunktion gibt die Anzahl von Bits zurück, die in der Bitsequenz festgelegt sind.
`flip`	Kehrt den Wert aller Bits in einem `bitset` oder ein einzelnes Bit an einer angegebenen Position um.
`none`	Überprüft, ob keines der Bits in einem `bitset`-Objekt auf 1 festgelegt wurde.
`reset`	Setzt alle Bits in einem `bitset`-Objekt oder ein Bit an einer angegebenen Position auf 0 zurück.
`set`	Legt alle Bits in einem `bitset`-Objekt oder ein Bit an einer angegebenen Position auf 1 fest.
`size`	Gibt die Anzahl von Bits eines `bitset`-Objekts zurück.
`test`	Überprüft, ob das Bit an einer angegebenen Position in einem `bitset`-Objekt auf 1 festgelegt ist.
`to_string`	Konvertiert ein `bitset`-Objekt in eine Zeichenfolgendarstellung.
`to_ullong`	Gibt die Summe der Bitwerte im `bitset`-Objekt als einen `unsigned long long`-Wert zurück.
`to_ulong`	Konvertiert ein `bitset`-Objekt in den `unsigned long`-Wert, der die Sequenz der enthalten Bits erzeugen würde, wenn er zum Initialisieren des `bitset`-Objekts verwendet werden würde.

Klassen

name	Beschreibung
`reference`	Eine Proxyklasse, die Verweise auf Bits bereitstellt, die in einem `bitset`-Objekt enthalten sind, das als unterstützende Klasse für den `operator[]` der `bitset`-Klasse dazu verwendet wird, auf einzelne Bits zuzugreifen sowie einzelne Bits zu verarbeiten.

Operatoren

Name	Beschreibung
`operator!=`	Überprüft ein `bitset`-Zielobjekt auf Ungleichheit mit einem angegebenen `bitset`-Objekt.
`operator&=`	Führt eine bitweise Kombination von Bitsets mit dem bitweisen "and" (`&`) -Vorgang aus.
`operator<<`	Verschiebt die Bits in einem `bitset`-Objekt um eine angegebene Anzahl von Positionen nach links und gibt das Ergebnis in einem neuen `bitset`-Objekt zurück.
`operator<<=`	Verschiebt die Bits in einem `bitset`-Objekt um eine angegebene Anzahl von Positionen nach links und gibt das Ergebnis im selben `bitset`-Objekt zurück.
`operator==`	Überprüft ein `bitset`-Zielobjekt auf Gleichheit mit einem angegebenen `bitset`-Objekt.
`operator>>`	Verschiebt die Bits in einem `bitset`-Objekt um eine angegebene Anzahl von Positionen nach rechts und gibt das Ergebnis in einem neuen `bitset`-Objekt zurück.
`operator>>=`	Verschiebt die Bits in einem `bitset`-Objekt um eine angegebene Anzahl von Positionen nach rechts und gibt das Ergebnis im selben `bitset`-Objekt zurück.
`operator[]`	Gibt einen Verweis auf ein Bit an einer angegebenen Position eines `bitset`-Objekts zurück, wenn das `bitset` geändert werden kann. Gibt andernfalls den Wert zurück, den das Bit an dieser Position hat.
operator^=	Führt eine bitweise Kombination von Bitsets mit dem bitweisen "xor" (`^`)-Vorgang aus.
`operator\|=`	Führt eine bitweise Kombination von Bitsets mit dem bitweisen Vorgang "oder" (`\|`) durch.
`operator~`	Kehrt alle Bits in einem Ziel-`bitset` um, und gibt das Ergebnis zurück.

Strukturen

Name	Beschreibung
`hash`

`all`

Testet alle Bits in diesem Bitset, um festzustellen, ob sie alle auf "true" festgelegt sind.

bool all() const;

Rückgabewert

Gibt zurück true , wenn alle Bits in diesem Satz wahr sind. Gibt zurück false , wenn mindestens ein Bit falsch ist.

`any`

Überprüft, ob ein Bit in der Sequenz auf 1 gesetzt ist.

bool any() const;

Rückgabewert

true wenn ein bit in dieser bitset Eigenschaft auf 1 festgelegt ist; false wenn alle Bits 0 sind.

Beispiel

// bitset_any.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 6 );
   bool b, rb;

   cout << "The original bitset b1( 6 ) is: ( "<< b1 << " )"
        << endl;

   b = b1.any ( );

   if ( b )
      cout << "At least one of the bits in bitset is set to 1."
           << endl;
   else
      cout << "None of the bits in bitset are set to 1."
           << endl;

   bitset<5> rb1;
   rb1 = b1.reset ( );

   cout << "The reset bitset is: ( "<< b1 << " )"
        << endl;

   rb = rb1.any ( );

   if ( rb )
      cout << "At least one of the bits in the reset bitset "
           << "are set to 1." << endl;
   else
      cout << "None of the bits in bitset b1 are set to 1."
           << endl;
}

The original bitset b1( 6 ) is: ( 00110 )
At least one of the bits in bitset is set to 1.
The reset bitset is: ( 00000 )
None of the bits in bitset b1 are set to 1.

`bitset`

Erstellt ein Objekt der Klasse bitset<N>, und initialisiert die Bits mit 0 (null) oder mit einem angegebenen Wert oder mit Werten, die aus Zeichen einer Zeichenfolge ermittelt wurden.

1) constexpr bitset();
2) bitset(unsigned long val);
3) constexpr bitset(unsigned long long val);
4) template <class CharType, class Traits, class Allocator>
    explicit bitset(
        const basic_string<CharType, Traits, Allocator>& str,
        typename basic_string<CharType, Traits, Allocator>::size_type pos = 0);
    
5) template <class CharType, class Traits, class Allocator>
    explicit bitset(
        const basic_string<CharType, Traits, Allocator>& str,
        typename basic_string<CharType, Traits, Allocator>::size_type pos,
        typename basic_string<CharType, Traits, Allocator>::size_type count,
        CharType Zero = CharType ('0'),
        CharType One = CharType ('1'));
    
6) template<class CharType>
    explicit bitset(
        const CharType* str,
        typename basic_string<CharType>::size_type
        n = basic_string<CharType>::npos,
        CharType zero = CharType('0'),
        CharType one = CharType('1'));

Parameter

val
Die nicht signierte ganze Zahl, deren Basis zwei Darstellung verwendet wird, um die Bits im bitset zu erstellenden Format zu initialisieren.

str
Die Zeichenfolge von Nullen und die Zeichenfolgen, die zum Initialisieren der bitset Bitwerte verwendet werden.

pos
Die Position des Zeichens in der Zeichenfolge, das von links nach rechts gezählt wird und mit Null beginnt, das zum Initialisieren des ersten Bits in der bitsetZeichenfolge verwendet wird.

count
Die Anzahl der Zeichen in der Zeichenfolge, die zum Bereitstellen von Anfangswerten für die Bits in der bitsetZeichenfolge verwendet wird.

Zero
Das Zeichen, das verwendet wird, um eine 0 (null) darzustellen. Standardmäßig ist dies '0'.

One
Das Zeichen, das verwendet wird, um eine Eins darzustellen. Standardmäßig ist dies '1'.

Hinweise

1) Erstellt ein Objekt der Klasse bitset<N> und initialisiert alle N-Bits auf einen Standardwert von Null.

2-3) Erstellt ein Objekt der Klasse bitset<N> und initialisiert die Bits aus dem val Parameter.

4) Erstellt ein Objekt der Klasse bitset<N> und initialisiert Bits aus den Zeichen, die in einer Zeichenfolge von Nullen und Zeichenfolgen angegeben sind. Wenn andere Zeichen als 0 oder 1 zeichen der Zeichenfolge sind, löst der Konstruktor ein Objekt der Klasse invalid argumentaus. Wenn die angegebene Position (pos) über die Länge der Zeichenfolge hinaus liegt, löst der Konstruktor ein Objekt der Klasse out_of_rangeaus. Der Konstruktor legt nur die Bits an Position j in der bitset Zeichenfolge fest, für die das Zeichen in der Zeichenfolge an position pos + j 1 ist. Standardmäßig ist pos 0.

5) Ähnlich wie 4) ein anderer Parameter, countder die Anzahl der zu initialisierenden Bits angibt. Es verfügt über zwei optionale Parameter und _Zero _One, die angeben, in welchem Zeichen str ein 0 Bit bzw. ein 1 Bit interpretiert werden soll.

6) Erstellt ein Objekt der Klasse bitset<N>, initialisieren die N-Bits auf Werte, die den Zeichen in einer Zeichenfolge im C-Stil von Nullen und Zeichenfolgen entsprechen. Sie rufen den Konstruktor auf, ohne die Zeichenfolge in einen Zeichenfolgentyp zu umwandeln, z. B.: bitset<5> b5("01011");

Beispiel

// bitset_bitset.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   // Using the default constructor
   using namespace std;
   bitset<2> b0;
   cout << "The set of bits in bitset<2> b0 is: ( "
        << b0 << " )." << endl;

   // Using the second member function
   bitset<5> b1 ( 6 );
   cout << "The set of bits in bitset<5> b1( 6 ) is: ( "
        << b1 << " )." << endl;

   // The template parameter N can be an expression
   bitset< 2 * sizeof ( int ) > b2;
   cout << "The set of bits in bitset< 2 * sizeof ( int ) > b2 is: ( "
        << b2 << " )." << endl;

   // The base two representation will be truncated
   // if its length exceeds the size of the bitset
   bitset<3> b3 ( 6 );
   cout << "The set of bits in bitset<3> b3( 6 ) is ( "
        << b3 << " )." << endl;

   // Using a c-style string to initialize the bitset
    bitset<7> b3andahalf ( "1001001" );
    cout << "The set of bits in bitset<7> b3andahalf ( \"1001001\" )"
         << " is ( " << b3andahalf << " )." << endl;

   // Using the fifth member function with the first parameter
   string bitval4 ( "10011" );
   bitset<5> b4 ( bitval4 );
   cout << "The set of bits in bitset<5> b4( bitval4 ) is ( "
        << b4 << " )." << endl;

   // Only part of the string may be used for initialization

   // Starting at position 3 for a length of 6 (100110)
   string bitval5 ("11110011011");
   bitset<6> b5 ( bitval5, 3, 6 );
   cout << "The set of bits in bitset<11> b5( bitval, 3, 6 ) is ( "
        << b5 << " )." << endl;

   // The bits not initialized with part of the string
   // will default to zero
   bitset<11> b6 ( bitval5, 3, 5 );
   cout << "The set of bits in bitset<11> b6( bitval5, 3, 5 ) is ( "
        << b6 << " )." << endl;

   // Starting at position 2 and continue to the end of the string
   bitset<9> b7 ( bitval5, 2 );
   cout << "The set of bits in bitset<9> b7( bitval, 2 ) is ( "
        << b7 << " )." << endl;
}

The set of bits in bitset<2> b0 is: ( 00 ).
The set of bits in bitset<5> b1( 6 ) is: ( 00110 ).
The set of bits in bitset<2 * sizeof ( int ) > b2 is: ( 00000000 ).
The set of bits in bitset<3> b3( 6 ) is ( 110 ).
The set of bits in bitset<5> b4( bitval4 ) is ( 10011 ).
The set of bits in bitset<11> b5( bitval, 3, 6 ) is ( 100110 ).
The set of bits in bitset<11> b6( bitval5, 3, 5 ) is ( 00000010011 ).
The set of bits in bitset<9> b7( bitval, 2 ) is ( 110011011 ).

`count`

Gibt die Anzahl der Bit-Sätze in der Bitsequenz an.

size_t count() const;

Rückgabewert

Die Anzahl der Bit-Sätze in der Bitsequenz.

Beispiel

// bitset_count.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
    using namespace std;

    bitset<5> b1(4);

    cout << "The collection of bits in the original bitset is: ( "
         << b1 << " )" << endl;

    size_t i;
    i = b1.count();
    cout << "The number of bits in the bitset set to 1 is: "
         << i << "." << endl;

    bitset<5> fb1;
    fb1 = b1.flip();

    cout << "The collection of flipped bits in the modified bitset "
         << "is: ( " << b1 << " )" << endl;

    size_t ii;
    ii = fb1.count();
    cout << "The number of bits in the bitset set to 1 is: "
         << ii << "." << endl;
}

The collection of bits in the original bitset is: ( 00100 )
The number of bits in the bitset set to 1 is: 1.
The collection of flipped bits in the modified bitset is: ( 11011 )
The number of bits in the bitset set to 1 is: 4.

`element_type`

Ein Typ, der gleichbedeutend mit dem Datentyp bool ist und verwendet werden kann, um auf Elementbits in einem bitset-Objekt zu verweisen.

typedef bool element_type;

Beispiel

// bitset_elem_type.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<3> b1 ( 2 );
   cout << "Original bitset b1(6) is: ( "<< b1 << " )"
        << endl;

   //Compare two ways to reference bits in a bitset
   bool b;
   bitset<5>::element_type e;

   b = b1.test ( 2 );
   if ( b )
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 1." << endl;
   else
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 0." << endl;
   b1[2] = 1;
   cout << "Bitset b1 modified by b1[2] = 1 is: ( "<< b1 << " )"
        << endl;

   e = b1.test ( 2 );
   if ( e )
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 1." << endl;
   else
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 0." << endl;
}

Original bitset b1(6) is: ( 010 )
The bit at position 2 of bitset b1has a value of 0.
Bitset b1 modified by b1[2] = 1 is: ( 110 )
The bit at position 2 of bitset b1has a value of 1.

`flip`

Kehrt den Wert aller Bits in einem bitset oder ein einzelnes Bit an einer angegebenen Position um.

bitset<N>& flip();
bitset<N>& flip(size_t pos);

Parameter

pos
Die Position des Bits, dessen Wert umgekehrt werden soll.

Rückgabewert

Eine Kopie der Geänderten bitset , für die die Memberfunktion aufgerufen wurde.

Hinweise

Die zweite Memberfunktion löst eine out_of_range Ausnahme aus, wenn die als Parameter angegebene Position größer als die Größe N des bitset<N> Bits ist, dessen Bit umgekehrt wurde.

Beispiel

// bitset_flip.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 6 );

   cout << "The collection of bits in the original bitset is: ( "
        << b1 << " )" << endl;

   bitset<5> fb1;
   fb1 = b1.flip ( );

   cout << "After flipping all the bits, the bitset becomes: ( "
        << fb1 << " )" << endl;

   bitset<5> f3b1;
   f3b1 = b1.flip ( 3 );

   cout << "After flipping the fourth bit, the bitset becomes: ( "
        << f3b1 << " )" << endl << endl;

   bitset<5> b2;
   int i;
   for ( i = 0 ; i <= 4 ; i++ )
   {
      b2.flip(i);
      cout << b2 << "  The bit flipped is in position "
           << i << ".\n";
   }
}

The collection of bits in the original bitset is: ( 00110 )
After flipping all the bits, the bitset becomes: ( 11001 )
After flipping the fourth bit, the bitset becomes: ( 10001 )

00001  The bit flipped is in position 0.
00011  The bit flipped is in position 1.
00111  The bit flipped is in position 2.
01111  The bit flipped is in position 3.
11111  The bit flipped is in position 4.

`hash`

template <class T> struct hash;
template <size_t N> struct hash<bitset<N>>;

none

Überprüft, ob keines der Bits in einem bitset-Objekt auf 1 festgelegt wurde.

bool none() const;

Rückgabewert

true wenn kein Bit auf bitset 1 festgelegt wurde; false wenn mindestens ein Bit auf 1 festgelegt wurde.

Beispiel

// bitset_none.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 6 );
   bool b, rb;

   cout << "Original bitset b1(6) is: ( " << b1 << " )"
        << endl;

   b = b1.none ( );

   if ( b )
      cout << "None of the bits in bitset b1 are set to 1."
           << endl;
   else
      cout << "At least one of the bits in bitset b1 is set to 1."
           << endl;

   bitset<5> rb1;
   rb1 = b1.reset ( );
   rb = rb1.none ( );
   if ( rb )
      cout << "None of the bits in bitset b1 are set to 1."
           << endl;
   else
      cout << "At least one of the bits in bitset b1 is set to 1."
           << endl;
}

Original bitset b1(6) is: ( 00110 )
At least one of the bits in bitset b1 is set to 1.
None of the bits in bitset b1 are set to 1.

`operator!=`

Überprüft ein Zielbitset auf Ungleichheit mit einem angegebenen Bitset.

bool operator!=(const bitset<N>& right) const;

Parameter

right
Das bitset soll mit dem Zielbitset für Ungleichheit verglichen werden.

Rückgabewert

true wenn die Bitsets unterschiedlich sind; false wenn sie identisch sind.

Hinweise

Bitsets müssen dieselbe Größe aufweisen.

Beispiel

// bitset_op_NE.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 7 );
   bitset<5> b3 ( 2 );
   bitset<4> b4 ( 7 );

   if ( b1 != b2 )
      cout << "Bitset b1 is different from bitset b2." << endl;
   else
      cout << "Bitset b1 is the same as bitset b2." << endl;

   if ( b1 != b3 )
      cout << "Bitset b1 is different from bitset b3." << endl;
   else
      cout << "Bitset b1 is the same as bitset b3." << endl;

   // This would cause an error because bitsets must have the
   // same size to be tested
   // if ( b1 != b4 )
   //   cout << "Bitset b1 is different from bitset b4." << endl;
   // else
   //   cout << "Bitset b1 is the same as bitset b4." << endl;
}

Bitset b1 is the same as bitset b2.
Bitset b1 is different from bitset b3.

`operator&=`

Führt eine bitweise Kombination von Bitsets mit dem bitweisen "and" (&) -Vorgang aus.

bitset<N>& operator&=(const bitset<N>& right);

Parameter

right
Das bitset soll bitweise mit dem Zielbitset kombiniert werden.

Rückgabewert

Das geänderte Zielbitset, das aus dem bitweisen "and" (&) -Vorgang mit dem bitset angegebenen Parameter resultiert.

Hinweise

Zwei Bits, die vom AND Operator kombiniert werden, werden zurückgegeben true , wenn jedes Bit wahr ist; andernfalls wird die Kombination zurückgegeben false.

Die beiden Bitsets müssen dieselbe Größe aufweisen.

Beispiel

// bitset_op_bitwise.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 11 );
   bitset<4> b3 ( 7 );

   cout << "The target bitset b1 is:    ( "<< b1 << " )." << endl;
   cout << "The parameter bitset b2 is: ( "<< b2 << " )." << endl;
   cout << endl;

   b1 &= b2;
   cout << "After bitwise AND combination,\n"
        << "the target bitset b1 becomes:   ( "<< b1 << " )."
        << endl;

   // Note that the parameter-specified bitset is unchanged
   cout << "The parameter bitset b2 remains: ( "<< b2 << " )."
        << endl;

   // The following would cause an error because the bisets
   // must be of the same size to be combined
   // b1 &= b3;
}

The target bitset b1 is:    ( 00111 ).
The parameter bitset b2 is: ( 01011 ).

After bitwise AND combination,
the target bitset b1 becomes:   ( 00011 ).
The parameter bitset b2 remains: ( 01011 ).

`operator<<`

Verschiebt die Bits in einem bitset-Objekt um eine angegebene Anzahl von Positionen nach links und gibt das Ergebnis in einem neuen bitset-Objekt zurück.

bitset<N> operator<<(size_t pos) const;

Parameter

pos
Die Anzahl der Positionen links, die die Bits im Bereich bitset verschoben werden sollen.

Rückgabewert

Das geänderte Bitset mit den Bits, die um die erforderliche Anzahl von Positionen nach links verschoben wurden.

Hinweise

Die Memberoperatorfunktion gibt zurück bitset(*this) <<= pos , wo <<= die Bits in einer bitset nach links angegebenen Anzahl von Positionen verschoben werden und das Ergebnis an das Ziel bitsetzurückgegeben wird.

Beispiel

// bitset_op_LS.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );

   cout << "The bitset b1 is: ( "<< b1 << " )." << endl;

   bitset<5> b2;
   b2 = b1 << 2;

   cout << "After shifting the bits 2 positions to the left,\n"
        << " the bitset b2 is: ( "<< b2 << " )."
        << endl;

   bitset<5> b3 = b2 >> 1;

   cout << "After shifting the bits 1 position to the right,\n"
        << " the bitset b3 is: ( " << b3 << " )."
        << endl;
}

`operator<<=`

Verschiebt die Bits in einem bitset-Objekt um eine angegebene Anzahl von Positionen nach links und gibt das Ergebnis im selben bitset-Objekt zurück.

bitset<N>& operator<<=(size_t pos);

Parameter

pos
Die Anzahl der Positionen links, in denen die Bits verschoben bitset werden sollen.

Rückgabewert

Die gezielte bitset Änderung, sodass die Bits nach links verschoben wurden, die erforderliche Anzahl von Positionen.

Hinweise

Wenn kein Element vorhanden ist, das an die Position verschoben werden kann, löscht die Funktion das Bit auf einen Wert von 0.

Beispiel

// bitset_op_LSE.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   cout << "The target bitset b1 is: ( "<< b1 << " )." << endl;
   b1 <<= 2;
   cout << "After shifting the bits 2 positions to the left,\n"
        << "the target bitset b1 becomes: ( "<< b1 << " )."
        << endl;
}

The target bitset b1 is: ( 00111 ).
After shifting the bits 2 positions to the left,
the target bitset b1 becomes: ( 11100 ).

`operator==`

Überprüft ein Zielbitset auf Gleichheit mit einem angegebenen Bitset.

bool operator==(const bitset<N>& right) const;

Parameter

right
Das bitset ist mit dem Zielbitset für die Gleichheit zu vergleichen.

Rückgabewert

true wenn die Bitsets identisch sind; false wenn sie anders sind.

Hinweise

Bitsets müssen dieselbe Größe aufweisen.

Beispiel

// bitset_op_EQ.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 7 );
   bitset<5> b3 ( 2 );
   bitset<4> b4 ( 7 );

   if ( b1 == b2 )
      cout << "Bitset b1 is the same as bitset b2." << endl;
   else
      cout << "Bitset b1 is different from bitset b2." << endl;

   if ( b1 == b3 )
      cout << "Bitset b1 is the same as bitset b3." << endl;
   else
      cout << "Bitset b1 is different from bitset b3." << endl;

   // This would cause an error because bitsets must have the
   // same size to be tested
   // if ( b1 == b4 )
   //   cout << "Bitset b1 is the same as bitset b4." << endl;
   // else
   //   cout << "Bitset b1 is different from bitset b4." << endl;
}

Bitset b1 is the same as bitset b2.
Bitset b1 is different from bitset b3.

`operator>>`

Verschiebt die Bits in einer bitset nach rechts angegebenen Anzahl von Positionen und gibt das Ergebnis an eine neue Bitmenge zurück.

bitset<N> operator>>(size_t pos) const;

Parameter

pos
Die Anzahl der Positionen rechts, die die Bits in der bitset Verschiebung sind.

Rückgabewert

Ein neues Bitset, bei dem die Bits nach rechts verschoben wurden, die erforderliche Anzahl von Positionen relativ zum Ziel bitset.

Beispiel

// bitset_op_RS.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   cout << "The bitset b1 is: ( "<< b1 << " )." << endl;

   bitset<5> b2;
   b2 = b1 << 2;

   cout << "After shifting the bits 2 positions to the left,\n"
        << "the bitset b2 is: ( "<< b2 << " )."
        << endl;
   bitset<5> b3 = b2 >> 1;

   cout << "After shifting the bits 1 position to the right,\n"
        << "the bitset b3 is: ( " << b3 << " )."
        << endl;
}

The bitset b1 is: ( 00111 ).
After shifting the bits 2 positions to the left,
the bitset b2 is: ( 11100 ).
After shifting the bits 1 position to the right,
the bitset b3 is: ( 01110 ).

`operator>>=`

Verschiebt die Bits in einem bitset-Objekt um eine angegebene Anzahl von Positionen nach rechts und gibt das Ergebnis im selben bitset-Objekt zurück.

bitset<N>& operator>>=(size_t pos);

Parameter

pos
Die Anzahl der Positionen rechts, die die Bits in der bitset Verschiebung sind.

Rückgabewert

Die gezielte bitset Änderung, sodass die Bits nach rechts verschoben wurden, die erforderliche Anzahl von Positionen.

Hinweise

Wenn kein Element vorhanden ist, das an die Position verschoben werden kann, löscht die Funktion das Bit auf einen Wert von 0.

Beispiel

// bitset_op_RSE.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 28 );
   cout << "The target bitset b1 is: ( "<< b1 << " )." << endl;

   b1 >>= 2;
   cout << "After shifting the bits 2 positions to the right,\n"
        << "the target bitset b1 becomes: ( "<< b1 << " )."
        << endl;
}

The target bitset b1 is: ( 11100 ).
After shifting the bits 2 positions to the right,
the target bitset b1 becomes: ( 00111 ).

`operator[]`

Gibt einen Verweis auf ein Bit an einer angegebenen Position eines bitset-Objekts zurück, wenn das bitset geändert werden kann. Gibt andernfalls den Wert zurück, den das Bit an dieser Position hat.

bool operator[](size_t pos) const;
reference operator[](size_t pos);

Parameter

pos
Die Position, die das Bit innerhalb der bitset.

Hinweise

Wenn Sie in Ihrem Build als 1 oder 2 definieren _ITERATOR_DEBUG_LEVEL , tritt in Ihrer ausführbaren Datei ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element außerhalb der Grenzen des bitsetElements zuzugreifen. Weitere Informationen finden Sie unter Checked Iterators (Überprüfte Iteratoren).

Beispiel

// bitset_op_REF.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bool b;
   bitset<5> b1 ( 6 );
   cout << "The initialized bitset<5> b1( 2 ) is: ( "<< b1 << " )."
        << endl;

   int i;
   for ( i = 0 ; i <= 4 ; i++ )
   {
      b = b1[ i ];
      cout << "  The bit in position "
           << i << " is " << b << ".\n";
   }
}

`operator^=`

Führt eine bitweise Kombination von Bitsets mit dem bitweisen "xor" (^)-Vorgang aus.

bitset<N>& operator^=(const bitset<N>& right);

Parameter

right
Das bitset soll bitweise mit dem Zielbitset kombiniert werden.

Rückgabewert

Das geänderte Zielbitset, das aus dem bitweisen "xor" (^)-Vorgang mit dem bitset angegebenen Parameter resultiert.

Hinweise

Zwei Bits kombiniert durch den bitweisen "xor"-Operator (^) geben true zurück, wenn mindestens eine, aber nicht beides der Bits sind true; andernfalls wird ihre Kombination zurückgegeben false.

Bitsets müssen dieselbe Größe aufweisen.

Beispiel

// bitset_op_bitwiseOR.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 11 );
   bitset<4> b3 ( 7 );

   cout << "The target bitset b1 is:    ( "<< b1 << " )." << endl;
   cout << "The parameter bitset b2 is: ( "<< b2 << " )." << endl;
   cout << endl;

   b1 ^= b2;
   cout << "After bitwise exclusive OR combination,\n"
        << "the target bitset b1 becomes:   ( "<< b1 << " )."
        << endl;

   // Note that the parameter-specified bitset in unchanged
   cout << "The parameter bitset b2 remains: ( "<< b2 << " )."
        << endl;

   // The following would cause an error because the bitsets
   // must be of the same size to be combined
   // b1 |= b3;
}

The target bitset b1 is:    ( 00111 ).
The parameter bitset b2 is: ( 01011 ).

After bitwise exclusive OR combination,
the target bitset b1 becomes:   ( 01100 ).
The parameter bitset b2 remains: ( 01011 ).

`operator|=`

Kombiniert zwei Bitsets mithilfe des bitweisen "or" (|)-Vorgangs.

bitset<N>& operator|=(const bitset<N>& right);

Parameter

right
Das bitset soll bitweise mit dem Ziel bitsetkombiniert werden.

Rückgabewert

Das geänderte Zielbitset, das aus dem bitweisen "or" (|) -Vorgang mit dem bitset angegebenen Parameter resultiert.

Hinweise

Zwei Bits, die vom inklusiven OR Operator kombiniert werden, werden zurückgegeben true , wenn mindestens eines der Bits lautet true; wenn beide Bits sind false, gibt ihre Kombination zurück false.

Bitsets müssen dieselbe Größe aufweisen.

Beispiel

// bitset_op_BIO.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 11 );
   bitset<4> b3 ( 7 );

   cout << "The target bitset b1 is:    ( "<< b1 << " )." << endl;
   cout << "The parameter bitset b2 is: ( "<< b2 << " )." << endl;
   cout << endl;

   b1 |= b2;
   cout << "After bitwise inclusive OR combination,\n"
        << "the target bitset b1 becomes:   ( "<< b1 << " )."
        << endl;

   // Note that the parameter-specified bitset in unchanged
   cout << "The parameter bitset b2 remains: ( "<< b2 << " )."
        << endl;

   // The following would cause an error because the bisets
   // must be of the same size to be combined
   // b1 |= b3;
}

The target bitset b1 is:    ( 00111 ).
The parameter bitset b2 is: ( 01011 ).

After bitwise inclusive OR combination,
the target bitset b1 becomes:   ( 01111 ).
The parameter bitset b2 remains: ( 01011 ).

`operator~`

Kehrt alle Bits in einem Zielbitset um und gibt das Ergebnis zurück.

bitset<N> operator~() const;

Rückgabewert

Das bitset mit all seinen Bits invertiert in Bezug auf das Ziel bitset.

Beispiel

// bitset_op_invert.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <bitset>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2;
   b2 = ~b1;

   cout << "Bitset b1 is: ( "<< b1 << " )." << endl;
   cout << "Bitset b2 = ~b1 is: ( "<< b2 << " )." << endl;

   // These bits could also be flipped using the flip member function
   bitset<5> b3;
   b3 = b1.flip( );
   cout << "Bitset b3 = b1.flip( ) is: ( "<< b2 << " )." << endl;
}

Bitset b1 is: ( 00111 ).
Bitset b2 = ~b1 is: ( 11000 ).
Bitset b3 = b1.flip( ) is: ( 11000 ).

`reference`

Eine Proxyklasse, die Verweise auf Bits bereitstellt, die in einem bitset-Objekt enthalten sind, das als unterstützende Klasse für den operator[] der bitset-Klasse dazu verwendet wird, auf einzelne Bits zuzugreifen sowie einzelne Bits zu verarbeiten.

class reference {
   friend class bitset<N>;
public:
   reference& operator=(bool val);
   reference& operator=(const reference& bitref);
   bool operator~() const;
   operator bool() const;
   reference& flip();
};

Parameter

val
Der Wert des Typobjekts bool , das einem Bit in einem bitsetObjekt zugewiesen werden soll.

bitref
Ein Verweis des Formulars x [ i ] auf das Bit an der Position i in bitset x.

Rückgabewert

Ein Verweis auf das Bit in der bitset angegebenen Argumentposition für die ersten, zweiten und fünften Memberfunktionen des Klassenverweises und true oder false, um den Wert des geänderten Bits in der bitset dritten und vierten Elementfunktion des Klassenverweises widerzuspiegeln.

Hinweise

Die Klasse reference ist nur als Hilfsklasse für die bitset operator[]. Die Memberklasse beschreibt ein Objekt, das auf ein einzelnes Bit innerhalb eines Objekts bitsetzugreifen kann. Lassen Sie uns b ein Objekt vom Typ boolund y x Objekte des Typs bitset<N>und i gültige j Positionen innerhalb eines solchen Objekts sein. Die Notation x [i] verweist auf das Bit an der Position i in Bitset x. Die Memberfunktionen der Klasse reference stellen in der genannten Reihenfolge die folgenden Vorgänge bereit:

Vorgang	Definition
`x`[`i`] = `b`	Speichert `bool` den Wert `b` an der Bitposition `i` in Bitmenge `x`.
`x`[`i`] = `y`[`j`]	Speichert den Wert des Bits `y`[ `j`] an der Bitposition `i` in Bitmenge `x`.
`b` = ~ `x`[`i`]	Speichert den gekippten Wert des Bits `x`[ `i`] in `bool` `b`.
`b` = `x`[`i`]	Speichert den Wert des Bits `x`[ `i`] in `bool` `b`.
`x`[`i`]. `flip`( )	Speichert den gekippten Wert des Bits `x`[ `i`] zurück an der Bitposition `i` in `x`.

Beispiel

// bitset_reference.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 2 );
   bitset<5> b2 ( 6 );
   cout << "The initialized bitset<5> b1( 2 ) is: ( "<< b1 << " )."
        << endl;
   cout << "The initialized bitset<5> b2( 6 ) is: ( "<< b2 << " )."
        << endl;

   // Example of x [i] = b storing bool b at bit position i
   // in bitset x
   b1[ 0 ] = true;
   cout << "The bitset<5> b1 with the bit at position 0 set to 1"
        << "is: ( "<< b1 << " )" << endl;

   // Example of x [i] = y [j] storing the bool value of the
   // bit at position j in bitset y at bit position i in bitset x
   b2 [4] = b1 [0];      // b1 [0] = true
   cout << "The bitset<5> b2 with the bit at position 4 set to the "
        << "value\nof the bit at position 0 of the bit in "
        << "bitset<5> b1 is: ( "<<  b2  << " )" << endl;

   // Example of b = ~x [i] flipping the value of the bit at
   // position i of bitset x and storing the value in an
   // object b of type bool
   bool b = ~b2 [4];      // b2 [4] = false
   if ( b )
      cout << "The value of the object b = ~b2 [4] "
           << "of type bool is true." << endl;
   else
      cout << "The value of the object b = ~b2 [4] "
           << "of type bool is false." << endl;

   // Example of b = x [i] storing the value of the bit at
   // position i of bitset x in the object b of type bool
   b = b2 [4];
   if ( b )
      cout << "The value of the object b = b2 [4] "
           << "of type bool is true." << endl;
   else
      cout << "The value of the object b = b2 [4] "
           << "of type bool is false." << endl;

   // Example of x [i] . flip ( ) toggling the value of the bit at
   // position i of bitset x
   cout << "Before flipping the value of the bit at position 4 in "
        << "bitset b2,\nit is ( "<<  b2  << " )." << endl;
   b2 [4].flip( );
   cout << "After flipping the value of the bit at position 4 in "
        << "bitset b2,\nit becomes ( "<<  b2  << " )." << endl;
   bool c;
   c = b2 [4].flip( );
   cout << "After a second flip, the value of the position 4 "
        << "bit in b2 is now: " << c << ".";
}

The initialized bitset<5> b1( 2 ) is: ( 00010 ).
The initialized bitset<5> b2( 6 ) is: ( 00110 ).
The bitset<5> b1 with the bit at position 0 set to 1 is: ( 00011 )
The bitset<5> b2 with the bit at position 4 set to the value
of the bit at position 0 of the bit in bitset<5> b1 is: ( 10110 )
The value of the object b = ~b2 [4] of type bool is false.
The value of the object b = b2 [4] of type bool is true.
Before flipping the value of the bit at position 4 in bitset b2,
it is ( 10110 ).
After flipping the value of the bit at position 4 in bitset b2,
it becomes ( 00110 ).
After a second flip, the value of the position 4 bit in b2 is now: 1.

`reset`

Setzt alle Bits in einem bitset-Objekt oder ein Bit an einer angegebenen Position auf 0 zurück.

bitset<N>& reset();
bitset<N>& reset(size_t pos);

Parameter

pos
Die Position des Bits, das bitset auf 0 zurückgesetzt werden soll.

Rückgabewert

Eine Kopie der bitset Elementfunktion, für die die Memberfunktion aufgerufen wurde.

Hinweise

Die zweite Memberfunktion löst eine out_of_range Ausnahme aus, wenn die angegebene Position größer als die Größe der bitset.

Beispiel

// bitset_reset.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 13 );
   cout << "The set of bits in bitset<5> b1(13) is: ( "<< b1 << " )"
        << endl;

   bitset<5> b1r3;
   b1r3 = b1.reset( 2 );
   cout << "The collection of bits obtained from resetting the\n"
        << "third bit of bitset b1 is: ( "<< b1r3 << " )"
        << endl;

   bitset<5> b1r;
   b1r = b1.reset( );
   cout << "The collecion of bits obtained from resetting all\n"
        << "the elements of the bitset b1 is: ( "<< b1r << " )"
        << endl;
}

The set of bits in bitset<5> b1(13) is: ( 01101 )
The collecion of bits obtained from resetting the
third bit of bitset b1 is: ( 01001 )
The collecion of bits obtained from resetting all
the elements of the bitset b1 is: ( 00000 )

`set`

Legt alle Bits in einem bitset-Objekt oder ein Bit an einer angegebenen Position auf 1 fest.

bitset<N>& set();

bitset<N>& set(
    size_t pos,
    bool val = true);

Parameter

pos
Die Position des Bits im bitset zugewiesenen Wert.

val
Der Wert, der dem Bit an der angegebenen Position zugewiesen werden soll.

Rückgabewert

Eine Kopie der bitset Elementfunktion, für die die Memberfunktion aufgerufen wurde.

Hinweise

Die zweite Memberfunktion löst eine out_of_range Ausnahme aus, wenn die angegebene Position größer als die Größe der bitset.

Beispiel

// bitset_set.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 6 );
   cout << "The set of bits in bitset<5> b1(6) is: ( "<< b1 << " )"
        << endl;

   bitset<5> b1s0;
   b1s0 = b1.set( 0 );
   cout << "The collecion of bits obtained from setting the\n"
        << "zeroth bit of bitset b1 is: ( "<< b1s0 << " )"
        << endl;

   bitset<5> bs1;
   bs1 = b1.set( );
   cout << "The collecion of bits obtained from setting all the\n"
        << "elements of the bitset b1 is: ( "<< bs1 << " )"
        << endl;
}

The set of bits in bitset<5> b1(6) is: ( 00110 )
The collecion of bits obtained from setting the
zeroth bit of bitset b1 is: ( 00111 )
The collecion of bits obtained from setting all the
elements of the bitset b1 is: ( 11111 )

`size`

Gibt die Anzahl von Bits eines bitset-Objekts zurück.

size_t size() const;

Rückgabewert

Die Anzahl der Bits, Nin einem bitset<N>.

Beispiel

// bitset_size.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main()
{
    using namespace std;

    bitset<5> b1(6);
    size_t i;

    cout << "The set of bits in bitset<5> b1( 6 ) is: ( "<< b1 << " )"
         << endl;

    i = b1.size();

    cout << "The number of bits in bitset b1 is: " << i << "."
         << endl;
}

The set of bits in bitset<5> b1( 6 ) is: ( 00110 )
The number of bits in bitset b1 is: 5.

`test`

Überprüft, ob das Bit an einer angegebenen Position in einem bitset-Objekt auf 1 festgelegt ist.

bool test(size_t pos) const;

Parameter

pos
Die Position des Bits im bitset zu prüfenden Wert.

Rückgabewert

truewenn das durch die Argumentposition angegebene Bit auf 1 festgelegt ist; andernfalls . false

Hinweise

Die Memberfunktion löst eine out_of_range

`to_string`

Konvertiert ein bitset-Objekt in eine Zeichenfolgendarstellung.

template <class charT = char, class traits = char_traits<charT>, class Allocator = allocator<charT> >
   basic_string<charT, traits, Allocator> to_string(charT zero = charT('0'), charT one = charT('1')) const;

Rückgabewert

Ein Zeichenfolgenobjekt der Klasse basic_string, wobei jeder Bitsatz in der bitset Zeichenfolge ein entsprechendes Zeichen von 1 und ein Zeichen von 0 aufweist, wenn das Bit nicht festgelegt ist.

Beispiel

// bitset_to_string.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );

   cout << "The ordered set of bits in the bitset<5> b1( 7 )"
        << "\n  that was generated by the number 7 is: ( "
        << b1 << " )" << endl;

   string s1;
   s1 =  b1.template to_string<char,
   char_traits<char>, allocator<char> >( );
   cout << "The string returned from the bitset b1"
        << "\n  by the member function to_string( ) is: "
        << s1 << "." << endl;
}

The ordered set of bits in the bitset<5> b1( 7 )
  that was generated by the number 7 is: ( 00111 )
The string returned from the bitset b1
  by the member function to_string( ) is: 00111.

`to_ullong`

Gibt einen unsigned long long Wert zurück, der dieselben Bits enthält, die wie der Inhalt des bitset Objekts festgelegt sind.

unsigned long long to_ullong() const;

Rückgabewert

Gibt die Summe der Bitwerte zurück, die sich in der Bitsequenz als eine unsigned long long. Dieser unsigned long long Wert würde dieselben Satzbits erneut erstellen, wenn er zum Initialisieren eines bitset.

Ausnahmen

Löst ein overflow_error Objekt aus, wenn ein Bit in der Bitsequenz einen Bitwert aufweist, der nicht als Wert vom Typ unsigned long longdargestellt werden kann.

Hinweise

Gibt die Summe der Bitwerte zurück, die sich in der Bitsequenz als eine unsigned long long.

`to_ulong`

Konvertiert ein bitset Objekt in die ganze Zahl, die die Sequenz der enthaltenen Bits generiert, wenn zum Initialisieren der bitset.

unsigned long to_ulong( ) const;

Rückgabewert

Eine ganze Zahl, die die Bits in einer bitset bei der Initialisierung der bitset.

Hinweise

Das Anwenden der Memberfunktion würde die ganze Zahl zurückgeben, die dieselbe Abfolge von 1 und 0 Ziffern aufweist, wie in einer Sequenz von Bits, die in der bitsetZeichenfolge enthalten sind.

Die Memberfunktion löst ein overflow_error Objekt aus, wenn ein Bit in der Bitsequenz einen Bitwert aufweist, der nicht als Wert vom Typ unsigned longdargestellt werden kann.

Beispiel

// bitset_to_ulong.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );

   cout << "The ordered set of bits in the bitset<5> b1( 7 )"
        << "\n  that was generated by the number 7 is: ( "
        << b1 << " )" << endl;

   unsigned long int i;
   i = b1.to_ulong( );
   cout << "The integer returned from the bitset b1,"
        << "\n  by the member function to_long( ), that"
        << "\n  generated the bits as a base two number is: "
        << i << "." << endl;
}

The ordered set of bits in the bitset<5> b1( 7 )
  that was generated by the number 7 is: ( 00111 )
The integer returned from the bitset b1,
  by the member function to_long( ), that
  generated the bits as a base two number is: 7.

Freigeben über

bitset-Klasse

Syntax

Parameter

Hinweise

Member

Konstruktoren

TypeDefs

Functions

Klassen

Operatoren

Strukturen

all

Rückgabewert

any

Rückgabewert

Beispiel

bitset

Parameter

Hinweise

Beispiel

count

Rückgabewert

Beispiel

element_type

Beispiel

flip

Parameter

Rückgabewert

Hinweise

Beispiel

hash

none

Rückgabewert

Beispiel

operator!=

Parameter

Rückgabewert

Hinweise

Beispiel

operator&=

Parameter

Rückgabewert

Hinweise

Beispiel

operator<<

Parameter

Rückgabewert

Hinweise

Beispiel

operator<<=

Parameter

Rückgabewert

Hinweise

Beispiel

operator==

Parameter

Rückgabewert

Hinweise

Beispiel

operator>>

Parameter

Rückgabewert

Beispiel

operator>>=

Parameter

Rückgabewert

Hinweise

Beispiel

operator[]

Parameter

Hinweise

Beispiel

operator^=

Parameter

Rückgabewert

Hinweise

Beispiel

operator|=

Parameter

`bitset`-Klasse

`all`

`any`

`bitset`

`count`

`element_type`

`flip`

`hash`

`operator!=`

`operator&=`

`operator<<`

`operator<<=`

`operator==`

`operator>>`

`operator>>=`

`operator[]`

`operator^=`

`operator|=`

`operator~`

`reference`

`reset`

`set`

`size`

`test`

`to_string`

`to_ullong`

`to_ulong`