std::bit_cast ​

什么是 std::bit_cast ​

std::bit_cast 是 C++20 引入的函数模板,定义在 <bit> 头文件中。它将一个对象的位表示(bit pattern)重新解释为另一个类型的值,是类型双关(type punning)的安全替代方案。

在 C++20 之前,要查看一个 float 的二进制表示,通常需要用 reinterpret_cast 或 memcpy,这些方式要么有未定义行为的风险,要么不能用在编译期。std::bit_cast 解决了这两个问题——它既安全又是 constexpr 的。

cpp
#include <bit>
#include <cstdint>

float f = 1.0f;
// 安全地查看 float 的位表示
auto bits = std::bit_cast<std::uint32_t>(f);

bit_cast 的签名和要求 ​

cpp
template<class To, class From>
constexpr To bit_cast(const From& from) noexcept;
要求说明
sizeof(To) == sizeof(From)源类型和目标类型大小必须相同
To 和 From 都是 TriviallyCopyable必须是可平凡复制的类型
To 是 TriviallyConstructible目标类型必须可平凡构造(用于 constexpr)

基本示例 ​

cpp
#include <iostream>
#include <bit>
#include <cstdint>
#include <cstring>
#include <array>
#include <iomanip>
#include <bitset>

// ============================
// 示例1:查看 float 的位表示
// ============================

void float_bits_demo() {
    float f = 1.0f;
    // 将 float 的 32 位重新解释为 uint32_t
    auto bits = std::bit_cast<std::uint32_t>(f);

    std::cout << "float 1.0f 的位表示: 0x"
              << std::hex << std::setfill('0') << std::setw(8)
              << bits << std::dec << std::endl;
    // 输出: 0x3f800000

    // IEEE 754: 符号位0, 指数01111111, 尾数00000000000000000000000
    std::cout << "二进制: " << std::bitset<32>(bits) << std::endl;
}

// ============================
// 示例2:double 和 uint64_t 互转
// ============================

void double_bits_demo() {
    double d = 3.14;
    auto bits = std::bit_cast<std::uint64_t>(d);

    std::cout << "double 3.14 的位表示: 0x"
              << std::hex << bits << std::dec << std::endl;

    // 反向转换:从 uint64_t 恢复 double
    auto restored = std::bit_cast<double>(bits);
    std::cout << "恢复: " << restored << std::endl;  // 3.14
}

// ============================
// 示例3:constexpr 用法
// ============================

constexpr double pi = 3.14159265358979;
constexpr auto pi_bits = std::bit_cast<std::uint64_t>(pi);  // 编译期计算

void constexpr_demo() {
    std::cout << "pi 的位表示(编译期计算): 0x"
              << std::hex << pi_bits << std::dec << std::endl;

    // 编译期检查
    static_assert(std::bit_cast<double>(pi_bits) == pi);
    std::cout << "static_assert 通过" << std::endl;
}

// ============================
// 示例4:对比 reinterpret_cast(不安全)
// ============================

void comparison_demo() {
    float f = 42.0f;

    // 方式1:reinterpret_cast(未定义行为!违反严格别名规则)
    // int bad = *reinterpret_cast<int*>(&f);  // UB!

    // 方式2:memcpy(安全但不是 constexpr)
    int via_memcpy;
    std::memcpy(&via_memcpy, &f, sizeof(f));

    // 方式3:bit_cast(安全且 constexpr)
    auto via_bit_cast = std::bit_cast<int>(f);

    std::cout << "memcpy 结果: " << via_memcpy << std::endl;
    std::cout << "bit_cast 结果: " << via_bit_cast << std::endl;
    std::cout << "两者相同: " << std::boolalpha
              << (via_memcpy == via_bit_cast) << std::endl;
}

// ============================
// 示例5:结构体之间的转换
// ============================

struct ColorRGBA {
    std::uint8_t r, g, b, a;
};

void struct_demo() {
    // uint32_t 和 ColorRGBA 大小相同(4字节)
    static_assert(sizeof(ColorRGBA) == sizeof(std::uint32_t));

    std::uint32_t packed = 0xFF8040C0;  // RGBA 打包值

    // 解包为结构体
    auto color = std::bit_cast<ColorRGBA>(packed);
    std::cout << "R=" << (int)color.r
              << " G=" << (int)color.g
              << " B=" << (int)color.b
              << " A=" << (int)color.a << std::endl;

    // 结构体打包为 uint32_t
    ColorRGBA red{255, 0, 0, 255};
    auto packed_red = std::bit_cast<std::uint32_t>(red);
    std::cout << "红色打包: 0x" << std::hex << packed_red << std::dec << std::endl;
}

// ============================
// 示例6:字节数组转换
// ============================

void byte_array_demo() {
    // 从字节数组构造 float
    std::array<std::uint8_t, 4> bytes = {0x00, 0x00, 0x80, 0x3F};

    auto f = std::bit_cast<float>(bytes);
    std::cout << "字节 {00,00,80,3F} = float " << f << std::endl;  // 1.0

    // float 转为字节数组
    float value = 2.0f;
    auto raw = std::bit_cast<std::array<std::uint8_t, 4>>(value);
    std::cout << "float 2.0 的字节: ";
    for (auto b : raw) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << (int)b << " ";
    }
    std::cout << std::dec << std::endl;
}

// ============================
// 示例7:检查浮点数的特殊值
// ============================

constexpr bool is_negative_zero(float f) {
    // 负零的位表示是 0x80000000
    return std::bit_cast<std::uint32_t>(f) == 0x80000000u;
}

constexpr bool is_nan(float f) {
    // NaN: 指数全1,尾数非零
    auto bits = std::bit_cast<std::uint32_t>(f);
    return ((bits >> 23) & 0xFF) == 0xFF && (bits & 0x7FFFFF) != 0;
}

void special_values_demo() {
    std::cout << std::boolalpha;
    std::cout << "0.0f 是负零: " << is_negative_zero(0.0f) << std::endl;
    std::cout << "-0.0f 是负零: " << is_negative_zero(-0.0f) << std::endl;

    float nan = std::numeric_limits<float>::quiet_NaN();
    std::cout << "NaN 检测: " << is_nan(nan) << std::endl;
    std::cout << "1.0 检测: " << is_nan(1.0f) << std::endl;
}

int main() {
    std::cout << "=== float 位表示 ===" << std::endl;
    float_bits_demo();

    std::cout << "\n=== double 位表示 ===" << std::endl;
    double_bits_demo();

    std::cout << "\n=== constexpr ===" << std::endl;
    constexpr_demo();

    std::cout << "\n=== 对比 ===" << std::endl;
    comparison_demo();

    std::cout << "\n=== 结构体 ===" << std::endl;
    struct_demo();

    std::cout << "\n=== 字节数组 ===" << std::endl;
    byte_array_demo();

    std::cout << "\n=== 特殊值检测 ===" << std::endl;
    special_values_demo();

    return 0;
}

bit_cast vs 其他类型双关方式 ​

方式安全性constexpr可移植备注
std::bit_cast安全是是C++20 推荐方式
std::memcpy安全否是C++20 前的安全方式
reinterpret_cast不安全(UB)否否违反严格别名规则
union 类型双关C 中安全,C++ 中 UB否不确定C++ 标准不允许

适用场景 ​

  • 查看浮点数的二进制表示(IEEE 754)
  • 序列化/反序列化中的类型转换
  • 网络协议中打包/解包数据
  • 颜色值的打包和解包
  • 编译期的位模式操作
  • 替代所有 memcpy 式的类型双关

常见问题 ​

bit_cast 和 static_cast 有什么区别?

static_cast 做的是值转换(比如 float 1.5 转 int 得到 1),bit_cast 做的是位模式重新解释(float 1.5 的 32 位直接当成 int 的 32 位)。

bit_cast 可以用于指针类型吗?

bit_cast 本身不限制指针类型,但指针类型不满足 constexpr 的要求。运行时可以用,但要注意得到的指针指向的地址是否有效。

如果目标类型没有对应的合法值会怎样?

未定义行为。比如把全 1 的位模式 bit_cast 为 bool(bool 只有 0 和 1 两个合法值)。

注意事项 ​

  • 源和目标类型的大小必须相同
  • 两种类型都必须是 TriviallyCopyable
  • 填充位(padding bits)的值是未指定的
  • 如果目标类型没有对应的合法值表示,行为未定义
  • 不要用于含引用成员的类型
  • 需要 <bit> 头文件

总结 ​

std::bit_cast 是 C++20 提供的安全类型双关工具,将一个对象的位表示重新解释为另一种类型。它替代了以前用 reinterpret_cast(有未定义行为风险)和 memcpy(不能用于编译期)的做法。bit_cast 既安全(不违反严格别名规则)又是 constexpr 的(可以在编译期使用)。典型用途包括查看浮点数的位表示、序列化数据打包解包、编译期位模式分析等。