std::bit_cast

template< class To, class From >
constexpr To bit_cast( const From& from ) noexcept;

Ermittelt einen Wert vom Typ To durch Neuinterpretation der Objektdarstellung von From. Jedes Bit in der Wertdarstellung des zurückgegebenen To-Objekts ist gleich dem entsprechenden Bit in der Objektdarstellung von from. Die Werte der Padding-Bits im zurückgegebenen To-Objekt sind unspezifiziert.

Wenn es keinen Wert vom Typ To gibt, der der erzeugten Wertdarstellung entspricht, ist das Verhalten undefiniert. Wenn es mehrere solcher Werte gibt, ist unspezifiziert, welcher Wert erzeugt wird.

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

• nicht einem Bit in der Wertdarstellung von From entspricht (d.h. es einem Padding-Bit entspricht), oder
• einem Bit entspricht 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:

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

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