std::byte

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Typunterstützung

Basistypen
Ganzzahltypen mit fester Breite (C++11)
Gleitkommatypen mit fester Breite (C++23)
ptrdiff_t size_t max_align_t (C++11)     byte (C++17)	nullptr_t (C++11) offsetof NULL
Numerische Grenzwerte
numeric_limits
C-Schnittstelle für numerische Grenzwerte
Laufzeit-Typinformationen
type_info type_index (C++11)	bad_typeid bad_cast

 

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

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

Ähnlich wie unsigned char kann er zur Adressierung des Rohspeichers anderer Objekte (Objektrepräsentation) verwendet werden, ist aber im Gegensatz zu unsigned char kein Zeichentyp und kein arithmetischer Typ. std::byte modelliert eine reine Bitsammlung und unterstützt lediglich Bitshift-Operationen 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)

Äquivalent zu: return IntegerType(b); Diese Überladung nimmt nur 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) Äquivalent zu: return b = b << shift; Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_integral_v<IntegerType> true ist.

2) Äquivalent zu: return b = b >> shift;

Diese Überladung nimmt nur 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) Äquivalent zu: return std::byte(static_cast<unsigned int>(b) << shift); Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_integral_v<IntegerType> true ist.

2) Äquivalent zu: return std::byte(static_cast<unsigned int>(b) >> shift);

Diese Überladung nimmt nur 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) Äquivalent zu: return l = l | r;.

2) Äquivalent zu: return l = l & r;.

3) Äquivalent zu: 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) Äquivalent zu: return std::byte(static_cast<unsigned int>(l) | static_cast<unsigned int>(r));.

2) Äquivalent zu: return std::byte(static_cast<unsigned int>(l) & static_cast<unsigned int>(r));.

3) Äquivalent zu: return std::byte(static_cast<unsigned int>(l) ^ static_cast<unsigned int>(r));.

4) Äquivalent zu: return std::byte(~static_cast<unsigned int>(b));

Hinweise

Ein numerischer Wert n kann mittels std::byte{n} in einen Byte-Wert umgewandelt werden, aufgrund der C++17 erweiterten Initialisierungsregeln für enum class.

Ein Byte kann wie üblich mit einer expliziten Umwandlung oder alternativ mit std::to_integer in einen numerischen Wert umgewandelt werden (z.B. um einen Integer-Hash eines Objekts zu erzeugen).

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

Beispiel

Führen Sie diesen Code aus

#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; // Error: cannot convert int to byte.
    std::byte y{1}; // OK
 
    // if (y == 13) {} // Error: cannot be compared.
    if (y == std::byte{13}) {} // OK, bytes are comparable
 
    int arr[]{1, 2, 3};
    // int c = a[y]; // Error: array subscript is not an integer
    [[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; // Error: b is not of arithmetic type
    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