Namespaces
Variants

    std::bitset<N>::bitset

    Aus de.cppreference.net
     
    C++
     
    Hilfsmittelbibliothek
    Sprachunterstützung
    Typunterstützung (grundlegende Typen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programmhilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationale Operatoren (veraltet in C++20)
    Integer-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::bitset
     
    bitset();
    		(1) (noexcept seit C++11)
    (constexpr seit C++11)    		 
    bitset( unsigned long val );
    		(2) (bis C++11) 
    constexpr bitset( unsigned long long val ) noexcept;
    		(seit C++11) 
    template< class CharT, class Traits, class Alloc >
explicit bitset
    ( const std::basic_string<CharT, Traits, Alloc>& str,
      typename std::basic_string
                   <CharT, Traits, Alloc>::size_type pos = 0,
      typename std::basic_string<CharT, Traits, Alloc>::size_type
          n = std::basic_string<CharT, Traits, Alloc>::npos,
      CharT zero = CharT('0'), CharT one = CharT('1') );
    		(3) (constexpr seit C++23) 
    template< class CharT, class Traits >
constexpr explicit bitset
    ( std::basic_string_view<CharT, Traits> str,
      std::size_t pos = 0, std::size_t n = std::size_t(-1),
      CharT zero = CharT('0'), CharT one = CharT('1') );
    		(4) (seit C++26) 
    template< class CharT >
explicit bitset( const CharT* str, std::size_t n = std::size_t(-1),
                 CharT zero = CharT('0'), CharT one = CharT('1') );
    		(5) (seit C++11)
    (constexpr seit C++23)

    Erzeugt ein neues bitset aus einer von mehreren optionalen Datenquellen:

    1) Standardkonstruktor. Erzeugt ein bitset, bei dem alle Bits auf Null gesetzt sind.
    2) Erzeugt ein bitset aus einer vorzeichenlosen Ganzzahl val.
    Gegeben sei die Anzahl der Bits in der Wertdarstellung von unsigned long(bis C++11)unsigned long long(seit C++11) als S:
    • Die ersten (rechtesten, niedrigstwertigen) std::min(S, N) Bitpositionen werden mit den entsprechenden Bitwerten von val initialisiert.
    • Falls S kleiner als N ist, werden die restlichen Bitpositionen auf Nullen initialisiert.
    3) Erzeugt ein bitset unter Verwendung der Zeichen in str. Eine optionale Startposition pos und Länge n können angegeben werden, sowie Zeichen, die alternative Werte für gesetzte (one) und nicht gesetzte (zero) Bits darstellen. Traits::eq() wird zum Vergleichen der Zeichenwerte verwendet.
    Die effektive Länge der initialisierenden Zeichenkette ist std::min(n, str.size() - pos).
    4) Ähnlich wie (3), verwendet jedoch einen std::basic_string_view anstelle eines std::basic_string.
    5) Ähnlich wie (3), verwendet jedoch ein const CharT* anstelle eines std::basic_string.

    Äquivalent zu bitset(n == std::basic_string<CharT>::npos
    ? std::basic_string<CharT>(str)
    : std::basic_string<CharT>(str, n), 0, n, zero, one)    .

    		(bis C++26)

    Äquivalent zu bitset(n == std::basic_string_view<CharT>::npos
    ? std::basic_string_view<CharT>(str)
    : std::basic_string_view<CharT>(str, n), 0, n, zero, one)    .

    		(seit C++26)

    Parameter

    val - Zahl, die zur Initialisierung des Bitsets verwendet wird
    str - Zeichenkette, die zur Initialisierung des Bitsets verwendet wird
    pos - ein Startoffset in str
    n - Anzahl der zu verwendenden Zeichen aus str
    zero - alternatives Zeichen für ungesetzte Bits in str
    one - alternatives Zeichen für gesetzte Bits in str

    Ausnahmen

    3,4) std::out_of_range wenn pos > str. size ( ) , std::invalid_argument wenn ein Zeichen weder one noch zero ist.
    5) std::invalid_argument falls ein Zeichen weder one noch zero ist.

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_constexpr_bitset 202207L (C++23) Ein mehr constexpr std::bitset , Überladungen ( 3,5 )
    __cpp_lib_bitset 202306L (C++26) Verbindung von std::bitset mit std::string_view , ( 4 )

    Beispiel

    Diesen Code ausführen 
    #include <bitset>
#include <climits>
#include <iostream>
#include <string>
int main()
{
    // leerer Konstruktor (1)
    std::bitset<8> b1; // [0,0,0,0,0,0,0,0]
    // unsigned long long Konstruktor (2)
    std::bitset<8> b2(42);          // [0,0,1,0,1,0,1,0]
    std::bitset<70> bl(ULLONG_MAX); // [0,0,0,0,0,0,1,1,1,...,1,1,1] in C++11
    std::bitset<8> bs(0xfff0);      // [1,1,1,1,0,0,0,0]
    // String-Konstruktor (3)
    std::string bit_string = "110010";
    std::bitset<8> b3(bit_string);       // [0,0,1,1,0,0,1,0]
    std::bitset<8> b4(bit_string, 2);    // [0,0,0,0,0,0,1,0]
    std::bitset<8> b5(bit_string, 2, 3); // [0,0,0,0,0,0,0,1]
    // String-Konstruktor mit benutzerdefinierten Null/Eins-Zeichen (3)
    std::string alpha_bit_string = "aBaaBBaB";
    std::bitset<8> b6(alpha_bit_string, 0, alpha_bit_string.size(),
                      'a', 'B');         // [0,1,0,0,1,1,0,1]
    // char* Konstruktor mit benutzerdefinierten Zeichen (5)
    std::bitset<8> b7("XXXXYYYY", 8, 'X', 'Y'); // [0,0,0,0,1,1,1,1]
    std::cout <<   "b1: " << b1 << "\nb2: " << b2 << "\nbl: " << bl
              << "\nbs: " << bs << "\nb3: " << b3 << "\nb4: " << b4
              << "\nb5: " << b5 << "\nb6: " << b6 << "\nb7: " << b7 << '\n';
}

    Mögliche Ausgabe: 

    b1: 00000000
b2: 00101010
bl: 0000001111111111111111111111111111111111111111111111111111111111111111
bs: 11110000
b3: 00110010
b4: 00000010
b5: 00000001
b6: 01001101
b7: 00001111

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 396 C++98 die Werte der Null- und Eins-Zeichen für Überladung (3)
    waren ​ 0 ​ und 1 (was nicht '0' und '1' entspricht)     		Parameter hinzugefügt, um
    Werte für diese Zeichen bereitzustellen
    LWG 457 C++98 S war CHAR_BIT * sizeof ( unsigned long )
    für Überladung (2) , aber unsigned long garantiert nicht,
    alle Bits zur Wertdarstellung zu verwenden     		Anzahl der Bits der
    Wertdarstellung
    stattdessen berücksichtigen
    LWG 2250 C++98 das Verhalten war undefiniert, wenn pos > str. size ( ) true ist wirft in diesem Fall immer
    eine Exception

    Siehe auch

    		Setzt Bits auf true oder gegebenen Wert
    (öffentliche Elementfunktion)
    		Setzt Bits auf false
    (öffentliche Elementfunktion)