Namespaces
Variants

    std::byte

    Von de.cppreference.net
     
    C++
     
    Hilfsmittelbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Feature-Test-Makros für die Bibliothek (C++20)
    Programmhilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstü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
    Vergleichsoperatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (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 Vokabelltypen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Typunterstützung
     
    Definiert in Header <cstddef> 
    enum class byte : unsigned char {};
    		(seit C++17)

    std::byte ist ein eigener Typ, der das Konzept eines Bytes, wie es in der C++-Sprachdefinition festgelegt ist, implementiert.

    Wie unsigned char kann es verwendet werden, um auf den rohen Speicher zuzugreifen, der von anderen Objekten belegt wird (Objektdarstellung), aber im Gegensatz zu unsigned char ist es kein Zeichentyp und kein arithmetischer Typ. std::byte modelliert eine bloße Ansammlung von Bits und unterstützt nur Bitschiebeoperationen mit einer Ganzzahl sowie bitweise und Vergleichsoperationen mit einem anderen std::byte.

    Nicht-Member-Funktionen

    std:: to_integer

    template < class IntegerType >
    constexpr IntegerType to_integer ( std :: byte b ) noexcept ;
    		(seit C++17)

    Entspricht: return IntegerType ( b ) ; Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_integral_v < IntegerType > true ist.

    std:: operator<<=,operator>>=

    template < class IntegerType >
    constexpr std :: byte & operator <<= ( std :: byte & b, IntegerType shift ) noexcept ;
    		(1) (seit C++17)
    template < class IntegerType >
    constexpr std :: byte & operator >>= ( std :: byte & b, IntegerType shift ) noexcept ;
    		(2) (seit C++17)
    1) Entspricht: return b = b << shift ; Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_integral_v < IntegerType > true ist.
    2) Entspricht: return b = b >> shift ;

    Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_integral_v < IntegerType > true ist.

    std:: operator<<,operator>>

    template < class IntegerType >
    constexpr std :: byte operator << ( std :: byte b, IntegerType shift ) noexcept ;
    		(1) (seit C++17)
    template < class IntegerType >
    constexpr std :: byte operator >> ( std :: byte b, IntegerType shift ) noexcept ;
    		(2) (seit C++17)
    1) Entspricht: return std :: byte ( static_cast < unsigned int > ( b ) << shift ) ; Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_integral_v < IntegerType > true ist.
    2) Entspricht: return std :: byte ( static_cast < unsigned int > ( b ) >> shift ) ;

    Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_integral_v < IntegerType > true ist.

    std:: operator|=,operator&=,operator^=

    constexpr std :: byte & operator | = ( std :: byte & l, std :: byte r ) noexcept ;
    		(1) (seit C++17)
    constexpr std :: byte & operator & = ( std :: byte & l, std :: byte r ) noexcept ;
    		(2) (seit C++17)
    constexpr std :: byte & operator ^ = ( std :: byte & l, std :: byte r ) noexcept ;
    		(3) (seit C++17)
    1) Entspricht: return l = l | r ; .
    2) Entspricht: return l = l & r ; .
    3) Entspricht: return l = l ^ r ; .

    std:: operator|,operator&,operator^,operator~

    constexpr std :: byte operator | ( std :: byte l, std :: byte r ) noexcept ;
    		(1) (seit C++17)
    constexpr std :: byte operator & ( std :: byte l, std :: byte r ) noexcept ;
    		(2) (seit C++17)
    constexpr std :: byte operator ^ ( std :: byte l, std :: byte r ) noexcept ;
    		(3) (seit C++17)
    constexpr std :: byte operator~ ( std :: byte b ) noexcept ;
    		(4) (seit C++17)
    1) Entspricht: return std :: byte ( static_cast < unsigned int > ( l ) | static_cast < unsigned int > ( r ) ) ; .
    2) Entspricht: return std :: byte ( static_cast < unsigned int > ( l ) & static_cast < unsigned int > ( r ) ) ; .
    3) Entspricht: return std :: byte ( static_cast < unsigned int > ( l ) ^ static_cast < unsigned int > ( r ) ) ; .
    4) Entspricht: return std :: byte ( ~ static_cast < unsigned int > ( b ) ) ;

    Hinweise

    Ein numerischer Wert n kann mithilfe von std :: byte { n } in einen Byte-Wert konvertiert werden, dank der C++17 relaxed enum class initialization Regeln.

    Ein Byte kann auf die übliche Weise in einen numerischen Wert umgewandelt werden (z.B. um einen Integer-Hash eines Objekts zu erzeugen) mit einer expliziten Konvertierung oder alternativ mit std::to_integer .

    Feature-Test Makro Wert Std Feature
    __cpp_lib_byte 201603L (C++17) std::byte

    Beispiel

    Diesen Code ausführen 
    #include <bitset>
#include <cassert>
#include <cstddef>
#include <iostream>
#include <utility>
std::ostream& operator<<(std::ostream& os, std::byte b)
{
    return os << std::bitset<8>(std::to_integer<int>(b));
}
int main()
{
    // std::byte y = 1; // Fehler: Kann int nicht in byte konvertieren.
    std::byte y{1}; // OK
    // if (y == 13) {} // Fehler: Kann nicht verglichen werden.
    if (y == std::byte{13}) {} // OK, Bytes sind vergleichbar
    int arr[]{1, 2, 3};
    // int c = a[y]; // Fehler: Array-Index ist keine Ganzzahl
    [[maybe_unused]] int i = arr[std::to_integer<int>(y)]; // OK
    [[maybe_unused]] int j = arr[std::to_underlying(y)];   // OK
    auto to_int = [](std::byte b) { return std::to_integer<int>(b); };
    std::byte b{42};
    assert(to_int(b) == 0b00101010);
    std::cout << b << '\n';
    // b *= 2; // Fehler: b ist kein arithmetischer Typ
    b <<= 1;
    assert(to_int(b) == 0b01010100);
    b >>= 1;
    assert(to_int(b) == 0b00101010);
    assert(to_int(b << 1) == 0b01010100);
    assert(to_int(b >> 1) == 0b00010101);
    b |= std::byte{0b11110000};
    assert(to_int(b) == 0b11111010);
    b &= std::byte{0b11110000};
    assert(to_int(b) == 0b11110000);
    b ^= std::byte{0b11111111};
    assert(to_int(b) == 0b00001111);
}

    Ausgabe: 

    00101010