std:: bit_cast

Erhalten Sie einen Wert vom Typ To durch Neuinterpretation der Objektdarstellung von From . Jedes Bit in der Wertedarstellung des zurückgegebenen To -Objekts entspricht dem entsprechenden Bit in der Objektdarstellung von from . Die Werte der Füllbits im zurückgegebenen To -Objekt sind nicht spezifiziert.

Wenn es keinen Wert des Typs To gibt, der der erzeugten Wertdarstellung entspricht, ist das Verhalten undefiniert. Wenn es mehrere solche Werte gibt, ist nicht spezifiziert, welcher Wert erzeugt wird.

Ein Bit in der Wertdarstellung des Ergebnisses ist unbestimmt , wenn es

• entspricht keinem Bit in der Wertdarstellung von From (d.h. es entspricht einem Padding-Bit), oder
• entspricht einem Bit eines Objekts, das (bis C++26) für das das kleinste umschließende Objekt (seit C++26) sich nicht innerhalb seiner Lebensdauer befindet, oder
• einen unbestimmten Wert hat.

Das Ergebnis enthält ansonsten keine unbestimmten oder fehlerhaften Werte.

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn sizeof ( To ) == sizeof ( From ) und sowohl To als auch From TriviallyCopyable -Typen sind.

Diese Funktionsvorlage ist constexpr genau dann, wenn jeder von To , From und die Typen aller Unterobjekte von To und From :

• ist kein Union-Typ;
• ist kein Zeigertyp;
• ist kein Zeiger-auf-Mitglied-Typ;
• ist kein volatile-qualifizierter Typ; und
• hat kein nicht-statisches Datenelement vom Referenztyp.

Parameter

Rückgabewert

Ein Objekt vom Typ To , dessen Wertdarstellung wie oben beschrieben ist.

Mögliche Implementierung

Um std::bit_cast zu implementieren, unter Vernachlässigung der Tatsache, dass es constexpr ist, kann std::memcpy verwendet werden, wenn es erforderlich ist, die Objektdarstellung als die eines anderen Typs zu interpretieren:

template<class To, class From>
std::enable_if_t<
    sizeof(To) == sizeof(From) &&
    std::is_trivially_copyable_v<From> &&
    std::is_trivially_copyable_v<To>,
    To>
// constexpr-Unterstützung benötigt Compiler-Magie
bit_cast(const From& src) noexcept
{
    static_assert(std::is_trivially_constructible_v<To>,
        "Diese Implementierung erfordert zusätzlich, "
        "dass der Zieltyp trivial konstruierbar ist");
    To dst;
    std::memcpy(&dst, &src, sizeof(To));
    return dst;
}

Hinweise

reinterpret_cast (oder gleichwertiger expliziter Cast ) zwischen Zeiger- oder Referenztypen sollte in den meisten Fällen nicht zur Neuinterpretation der Objektdarstellung verwendet werden, aufgrund der Type-Aliasing-Regel .

Beispiel

#include <bit>
#include <cstdint>
#include <iostream>
constexpr double f64v = 19880124.0; 
constexpr auto u64v = std::bit_cast<std::uint64_t>(f64v);
static_assert(std::bit_cast<double>(u64v) == f64v); // Rundreise
constexpr std::uint64_t u64v2 = 0x3fe9000000000000ull;
constexpr auto f64v2 = std::bit_cast<double>(u64v2);
static_assert(std::bit_cast<std::uint64_t>(f64v2) == u64v2); // Rundreise
int main()
{
    std::cout
        << "std::bit_cast<std::uint64_t>(" << std::fixed << f64v << ") == 0x"
        << std::hex << u64v << '\n'
        << "std::bit_cast<double>(0x" << std::hex << u64v2 << ") == "
        << std::fixed << f64v2 << '\n';
}

std::bit_cast<std::uint64_t>(19880124.000000) == 0x4172f58bc0000000
std::bit_cast<double>(0x3fe9000000000000) == 0.781250

Fehlerberichte

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

Siehe auch