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 的(可以在编译期使用)。典型用途包括查看浮点数的位表示、序列化数据打包解包、编译期位模式分析等。