std:: bit_cast

Obtenga 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 de objeto de from . Los valores de los bits de relleno en el objeto To devuelto no están especificados.

Si no hay ningún valor de tipo To que corresponda a la representación de valor producida, el comportamiento es indefinido. Si hay múltiples valores de este tipo, qué valor se produce no está especificado.

Un bit en la representación de valor del resultado es indeterminado si

• no corresponde a un bit en la representación de valor de From (es decir, corresponde a un bit de relleno), o
• corresponde a un bit de un objeto que (until C++26) para el cual el objeto contenedor más pequeño (since C++26) no está dentro de su lifetime , o
• tiene un indeterminate value .

El resultado no contiene ningún otro valor indeterminado o erróneo.

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

Esta plantilla de función es constexpr si y solo si cada uno de To , From y los tipos de todos los subobjetos de To y From :

• no es un tipo unión;
• no es un tipo puntero;
• no es un tipo puntero a miembro;
• no es un tipo calificado como volátil; y
• no tiene ningún miembro de datos no estáticos de tipo referencia.

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