std::bit_cast

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

Obtiene un valor de tipo To reinterpretando la representación del objeto de From. Cada bit en la representación de valor del objeto To devuelto es igual al bit correspondiente en la representación del objetofrom de To. Los valores de los bits de relleno en el objeto

devuelto no están especificados. ToSi no hay un valor de tipo

correspondiente a la representación de valor producida, el comportamiento no está definido. Si hay múltiples valores, cuál se produce no está especificado. Un bit en la representación de valor del resultado es indeterminado

• si Fromno corresponde a un bit en la representación de valor de
• (es decir, corresponde a un bit de relleno), ocorresponde a un bit de un objeto que(hasta C++26)para el cual el objeto contenedor más pequeño(desde C++26) no está dentro de su vida útil
• , otiene un valor indeterminado

(desde C++26)

(desde C++26)sizeof(To) == sizeof(From)Esta sobrecarga participa en la resolución de sobrecarga solo si To y ambos From y son tipos TriviallyCopyable

. constexprEsta plantilla de función es To si y solo si cada uno de From, To y los tipos de todos los subobjetos de From y

• :
• no es un tipo unión;
• no es un tipo puntero;
• no es un tipo puntero a miembro;
• no es un tipo calificado como volatile; y

Parámetros

Valor de retorno

Un objeto de tipo To cuya representación de valor es como se describe anteriormente.

Implementación posible

Para implementar std::bit_cast , ignorando el hecho de que es constexpr , std::memcpy puede utilizarse, cuando sea necesario, para interpretar la representación del objeto como la de otro tipo:

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>
// el soporte constexpr requiere magia del compilador
bit_cast(const From& src) noexcept
{
    static_assert(std::is_trivially_constructible_v<To>,
        "Esta implementación requiere adicionalmente "
        "que el tipo destino sea trivialmente construible");
    To dst;
    std::memcpy(&dst, &src, sizeof(To));
    return dst;
}

Notas

reinterpret_cast (o el equivalente cast explícito ) entre tipos de puntero o referencia no debe utilizarse para reinterpretar la representación de objetos en la mayoría de los casos debido a la regla de aliasing de tipos .

Ejemplo

#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); // ida y vuelta
constexpr std::uint64_t u64v2 = 0x3fe9000000000000ull;
constexpr auto f64v2 = std::bit_cast<double>(u64v2);
static_assert(std::bit_cast<std::uint64_t>(f64v2) == u64v2); // ida y vuelta
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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también