通过重新解释底层位模式在类型间转换。

语法

返回 新类型 类型的值。

解释

与 static_cast 不同，但与 const_cast 类似，reinterpret_cast 表达式不会编译成任何 CPU 指令（除非在整数和指针间转换，或在指针表示依赖其类型的不明架构上）。它纯粹是一个编译时指令，指示编译器将 表达式 视为如同具有 新类型 类型一样处理。

唯有下列转换能用 reinterpretcast 进行，但若转换会转型走常量性或易变性_则亦不允许。

1) 整型、枚举、指针或成员指针类型的表达式可转换到其自身的类型。产生的值与 表达式 的相同。(C++11 起)

2) 指针能转换成大小足以保有其类型所有值的任何整型类型（例如转换成 std::uintptr_t）

3) 任何整型或枚举类型的值可转换到指针类型。指针转换到有足够大小的整数再转换回同一指针类型后，保证拥有其原值，否则结果指针无法安全地解引用（不保证相反方向的往返转换；相同指针可拥有多种整数表示）。不保证空指针常量 NULL 或整数零生成目标类型的空指针值；为此目的应该用 static_cast 或隐式转换。

4) 任何 std::nullptr_t 类型的值，包含 nullptr，可转换成任何整型类型，如同它是 (void*)0 一样，但没有值能转换成 std::nullptr_t，甚至 nullptr 也不行：为该目的应该用 static_cast。(C++11 起)

5) 任何对象指针类型 T1 可转换成指向对象指针类型 cv T2 。这严格等价于 static_cast<cv T2>(staticcast<cv void*>(表达式))（这意味着，若 T2 的对齐要求不比 T1 的更严格，则指针值不改变，且将结果指针转换回原类型将生成其原值）。任何情况下，只有类型别名化（type aliasing）_规则允许（见下文）时，结果指针才可以安全地解引用

6) T1 类型的左值表达式可转换成到另一个类型 T2 的引用。结果是与原左值指代同一对象，但有不同类型的左值或亡值。不创建临时量，不进行复制，不调用构造函数或转换函数。只有类型别名化（type aliasing）规则允许（见下文）时，结果指针才可以安全地解引用

7) 任何函数指针可转换成指向不同函数类型的指针。通过指向不同函数类型的指针调用函数是未定义的，但将这种指针转换回指向原函数类型的指针将生成指向原函数的指针值。

8) 一些实现上（特别是在任何 POSIX 兼容的系统上，即基于 dlsym 的要求），函数指针可以转换成 void* 或任何其他对象指针，反之亦然。若实现支持双向的转换，则转换回原类型将生成原值，否则结果指针不能安全地解引用或调用。

9) 任何指针类型的空指针值可转换成任何其他指针类型，产生该类型的空指针值。注意不能用 reinterpret_cast 将空指针常量 nullptr 或任何其他 std::nullptr_t 类型的值转换为指针：为此目的应该使用隐式转换或 static_cast。

10) 成员函数指针可转换成指向不同类型的不同成员函数的指针。转换回原类型将生成原值，否则结果指针不能安全使用。

11) 指向某类 T1 的成员对象的指针可转换成指向另一个类 T2 的另一个成员对象的指针。若 T2 的对齐不比 T1 更严格，则转换回原类型 T1 将生成原值，否则不能安全地使用结果指针。

同所有转型表达式，结果是：

• 左值，若 new_type 是左值引用或到函数类型的右值引用；
• 亡值，若 new_type 是到对象类型的右值引用；
• 否则为纯右值。

关键词

reinterpret_cast

类型别名化

凡在试图通过 AliasedType 类型的泛左值读或修改类型为 DynamicType 的对象的值时，行为未定义，除非下列之一为真：

• AliasedType 与 DynamicType 相似。
• AliasedType 是 DynamicType 的（可有 cv 限定的）有符号或无符号变体。
• AliasedType 为 std::byte、 (C++17 起)char 或 unsigned char：这容许将任何对象的对象表示作为一个字节数组加以检验。

非正式地说，忽略顶层 cv 限定性，若两个类型符合下列条件，则它们相似：

• 它们是同一类型；或
• 它们都是指针，且被指向的类型相似；或
• 它们都是指向相同类的成员指针，且被指向的成员类型相似；或

例如：

• 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 与 std::pair 不相似。
  
  此规则允许进行基于类型的别名分析，即编译器假设通过一个类型的泛左值读取的值，不会被通过不同类型的泛左值的写入所修改（依据上述例外情况）。

注意，许多 C++ 编译器作为非标准语言扩展放松此规则，以允许通过 union 的不活跃成员的进行类型错误的访问（这种访问在 C 中并不是未定义的）。

注解

标准中定义严格别名化规则的段落含有两条额外条例，部分地是从 C 继承而来：

• AliasedType 为聚合类型或 union 类型，它保有前述各类型之一作为其元素或非静态成员（递归地包含子聚合体的元素和被包含的联合体的非静态数据成员）。
• AliasedType 为 DynamicType 的（可有 cv 限定的）基类。

这些条例所描述的情况不可能出现于 C++，从而从上面的讨论中省略。在 C 中，聚合复制和赋值将聚合体对象作为整体访问。但 C++ 中始终通过成员函数调用进行这种行动，这会访问单独的子对象而非整个对象（或在联合体的情况下，复制对象表示，即经由 unsigned char）。见核心问题 2051。

假设符合对齐要求，则 reinterpretcast 在处理[指针可互转换_]($5efc296e62b5adef.md#.E6.8C.87.E9.92.88.E5.8F.AF.E4.BA.92.E8.BD.AC.E6.8D.A2)对象的少数受限情况外，不更改指针的值：

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

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

示例

演示 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 << "The value of &i is 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 << "This system is little-endian\n";
    else
        std::cout << "This system is big-endian\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);
}

可能的输出：

The value of &i is 0x7fff352c3580
42
This system is little-endian
42