reinterpret_cast 转换
通过重新解释底层位模式在类型间转换。
语法
reinterpret_cast < 新类型 > ( 表达式 )
|
|||||||||
返回 新类型 类型的值。
解释
与 static_cast 不同,但与 const_cast 类似,reinterpret_cast 表达式不会编译成任何 CPU 指令(除非在整数和指针间转换,或在指针表示依赖其类型的不明架构上)。它纯粹是一个编译时指令,指示编译器将 表达式 视为如同具有 新类型 类型一样处理。
只有下列转换在不去除常量性或易变性的场合才能用 reinterpret_cast 执行。
T1*
可转换成指向对象指针类型 cv T2*
。这严格等价于 static_cast<cv T2*>(static_cast<cv void*>(表达式))(这意味着,若 T2
的对齐要求不比 T1
的更严格,则指针值不改变,且将结果指针转换回原类型将生成其原值)。任何情况下,只有类型别名化(type aliasing)规则允许(见下文)时,结果指针才可以安全地解引用。T1
类型的左值表达式可转换成到另一个类型 T2
的引用。结果是与原左值指代同一对象,但有不同类型的左值或亡值。不创建临时量,不进行复制,不调用构造函数或转换函数。只有类型别名化(type aliasing)规则允许(见下文)时,结果引用才可以安全访问。T1
的成员对象的指针可转换成指向另一个类 T2
的另一个成员对象的指针。若 T2
的对齐不比 T1
更严格,则转换回原类型 T1
将生成原值,否则不能安全地使用结果指针。同所有转型表达式,结果是:
- 左值,如果 新类型 是左值引用或到函数类型的右值引用;
- 亡值,如果 新类型 是到对象类型的右值引用;
- 否则为纯右值。
关键词
类型别名化
如果下列条件均不满足,每当试图通过 别名类型
类型的泛左值读或修改类型为 动态类型
的对象的值时,行为未定义:
-
别名类型
与动态类型
相似。 -
别名类型
是动态类型
的(可有 cv 限定的)有符号或无符号变体。 -
别名类型
为 std::byte、 (C++17 起)char 或 unsigned char:这容许将任何对象的对象表示作为一个字节数组加以检验。
非正式地说,忽略顶层 cv 限定性,若两个类型符合下列条件,则它们相似:
- 它们是同一类型;或
- 它们都是指针,且被指向的类型相似;或
- 它们都是指向相同类的成员指针,且被指向的成员类型相似;或
|
(C++20 前) |
|
(C++20 起) |
例如:
- const int * volatile * 与 int * * const 相似;
- const int (* volatile S::* const)[20] 与 int (* const S::* volatile)[20] 相似;
- int (* const *)(int *) 与 int (* volatile *)(int *) 相似;
- int (S::*)() const 与 int (S::*)() 不相似;
- int (*)(int *) 与 int (*)(const int *) 不相似;
- const int (*)(int *) 与 int (*)(int *) 不相似;
- int (*)(int * const) 与 int (*)(int *) 相似(它们是同一类型);
- std::pair<int, int> 与 std::pair<const int, int> 不相似。
此规则允许进行基于类型的别名分析,即编译器假设通过一个类型的泛左值读取的值,不会被通过不同类型的泛左值的写入所修改(依据上述例外情况)。
注意,许多 C++ 编译器作为非标准语言扩展放松此规则,以允许通过 union 的不活跃成员的进行类型错误的访问(这种访问在 C 中并不是未定义的)。
注解
标准中定义严格别名化规则的段落含有两条额外条例,部分从 C 继承而来:
-
别名类型
为聚合类型或 union 类型,它保有前述各类型之一作为其元素或非静态成员(递归地包含子聚合体的元素和被包含的联合体的非静态数据成员)。 -
别名类型
为动态类型
的(可有 cv 限定的)基类。
这些条例所描述的情况不可能出现于 C++,从而从上面的讨论中省略。在 C 中,聚合复制和赋值将聚合体对象作为整体访问。但 C++ 中始终通过成员函数调用进行这种行动,这会访问单独的子对象而非整个对象(或在联合体的情况下,复制对象表示,即经由 unsigned char)。见核心问题 2051。
假设符合对齐要求,则 reinterpret_cast
在处理指针可互转换对象的少数受限情况外,不更改指针的值:
struct S1 { int a; } s1; struct S2 { int a; private: int b; } s2; // 非标准布局 union U { int a; double b; } u = {0}; int arr[2]; int* p1 = reinterpret_cast<int*>(&s1); // p1 的值为“指向 s1.a 的指针” // 因为 s1.a 与 s1 为指针可互转换 int* p2 = reinterpret_cast<int*>(&s2); // reinterpret_cast 不更改 p2 的值为“指向 s2 的指针”。 int* p3 = reinterpret_cast<int*>(&u); // p3 的值为“指向 u.a 的指针”:u.a 与 u 指针可互转换 double* p4 = reinterpret_cast<double*>(p3); // p4 的指针为“指向 u.b 的指针”:u.a 与 u.b // 指针可互转换,因为都与 u 指针可互转换 int* p5 = reinterpret_cast<int*>(&arr); // reinterpret_cast 不更改 p5 的值为“指向 arr 的指针”
在不实际代表适当类型的对象的泛左值(例如通过 reinterpret_cast
所获得)上,进行代表非静态数据成员或非静态成员函数的成员访问,将导致未定义行为:
struct S { int x; }; struct T { int x; int f(); }; struct S1 : S {}; // 标准布局 struct ST : S, T {}; // 非标准布局 S s = {}; auto p = reinterpret_cast<T*>(&s); // p 的值为“指向 s 的指针” auto i = p->x; // 类成员访问表达式为未定义行为:s 不是 T 对象 p->x = 1; // 未定义行为 p->f(); // 未定义行为 S1 s1 = {}; auto p1 = reinterpret_cast<S*>(&s1); // p1 的值为“指向 S 的 s1 子对象的指针” auto i = p1->x; // OK p1->x = 1; // OK ST st = {}; auto p2 = reinterpret_cast<S*>(&st); // p2 的值为“指向 st 的指针” auto i = p2->x; // 未定义行为 p2->x = 1; // 未定义行为
许多编译器在这种情况下发布“严格别名化”警告,即使在技术上这种构造所违背的并非称为“严格别名化规则”段落的规则。
严格别名化及其相关规则的目的,是启用基于类型的别名分析,若程序能合法地创建一种情形,使得两个指向无关类型的指针(例如一个 int* 和一个 float*)能同时存在并可一同用于加载或存储同一内存(见此 SG12 reflector 上的邮件),则别名分析会普遍无效。故任何看起来能够创建这种情形的技巧都必然导致未定义行为。
当需要将对象的字节解释为不同类型的值时,可以使用 std::memcpy 或 std::bit_cast (C++20 起):
double d = 0.1; std::int64_t n; static_assert(sizeof n == sizeof d); // n = *reinterpret_cast<std::int64_t*>(&d); // 未定义行为 std::memcpy(&n, &d, sizeof d); // OK n = std::bit_cast<std::int64_t>(d); // 亦 OK
若实现提供 std::intptr_t 与/或 std::uintptr_t,则从指向对象类型或 cv void 的指针到这些类型的转型始终为良定义。然而这对于函数指针并不保证。 |
(C++11 起) |
缺陷报告
下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。
DR | 应用于 | 出版时的行为 | 正确行为 |
---|---|---|---|
CWG 195 | C++98 | 不允许函数指针和对象指针间的转换 | 改为条件性支持 |
示例
演示 reinterpret_cast 的一些用法:
#include <cstdint> #include <cassert> #include <iostream> int f() { return 42; } int main() { int i = 7; // 指针到整数并转回 std::uintptr_t v1 = reinterpret_cast<std::uintptr_t>(&i); // 不能误用 static_cast std::cout << "&i 的值是 0x" << std::hex << v1 << '\n'; int* p1 = reinterpret_cast<int*>(v1); assert(p1 == &i); // 到另一函数指针并转回 void(*fp1)() = reinterpret_cast<void(*)()>(f); // fp1(); 未定义行为 int(*fp2)() = reinterpret_cast<int(*)()>(fp1); std::cout << std::dec << fp2() << '\n'; // 安全 // 通过指针的类型别名化 char* p2 = reinterpret_cast<char*>(&i); if(p2[0] == '\x7') std::cout << "本系统是小端的\n"; else std::cout << "本系统是大端的\n"; // 通过引用的类型别名化 reinterpret_cast<unsigned int&>(i) = 42; std::cout << i << '\n'; [[maybe_unused]] const int &const_iref = i; // int &iref = reinterpret_cast<int&>(const_iref); // 编译错误——不能去除 const // 必须用 const_cast 代替:int &iref = const_cast<int&>(const_iref); }
可能的输出:
&i 的值是 0x7fff352c3580 42 本系统是小端的 42
参阅
const_cast 转换 | 添加或移除 const |
static_cast 转换 | 进行基本转换 |
dynamic_cast 转换 | 进行有检查的多态转换 |
显式转型 | 在类型间自由转换 |
标准转换 | 从一个类型到另一类型的隐式转换 |