reinterpret_cast conversion

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

语法

返回类型为 target-type 的值。

说明

与 static_cast 不同，但类似于 const_cast ， reinterpret_cast 表达式不会编译为任何 CPU 指令（除了在整数与指针之间转换时，或在某些特殊架构上指针表示依赖于其类型时进行指针转换的情况）。它主要是一个编译时指令，指示编译器将 expression 视为具有 target-type 类型。

只有以下转换可以通过 reinterpret_cast 实现，除非这些转换会 去除常量性 （或易变性）。

与所有强制转换表达式一样，结果是：

• 若 target-type 是左值引用类型 或函数类型的右值引用 (C++11 起) ，则为左值；

• 否则为纯右值。

类型别名

类型可访问性

若类型 T_ref 与下列任一类型 相似 ，则具有 动态类型 T_obj 的对象可通过类型为 T_ref 的 左值 (C++11 前) 泛左值 (C++11 起) 进行 类型可访问 ：

• char , unsigned char 或 std::byte (C++17 起) ：允许将任何对象的 对象表示 作为字节数组进行检视。
• T_obj
• 与 T_obj 对应的有符号或无符号类型

如果程序试图通过一个类型不可访问的 lvalue (until C++11) glvalue (since C++11) 来读取或修改对象的存储值，其行为是未定义的。

此规则启用基于类型的别名分析，编译器据此假定通过某类型的泛左值读取的值不会被写入不同类型的泛左值所修改（受前述例外情况约束）。

请注意，许多C++编译器会放宽此规则，作为非标准语言扩展，允许通过 联合体 的非活跃成员进行错误类型访问（此类访问在C语言中不属于未定义行为）。

调用兼容性

若满足以下任一条件，则类型 T_call 与函数类型 T_func 是 调用兼容的 ：

• T_call 与 T_func 类型相同。

如果通过表达式调用函数，且该表达式的 函数类型 与被调用函数定义的类型不兼容，则行为是未定义的。

注释

假设对齐要求得到满足， 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); // p2 的值不会被 reinterpret_cast 改变
                                       // 且为“指向 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); // p5 的值不会被 reinterpret_cast 改变
                                        // 且为“指向 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 的值为"指向 s1 中 S 子对象的指针"
auto i = p1->x; // 正确
p1->x = 1;      // 正确
ST st = {};
auto p2 = reinterpret_cast<S*>(&st); // p2 的值为"指向 st 的指针"
auto i = p2->x; // 未定义行为
p2->x = 1;      // 未定义行为

许多编译器在此类情况下会发出"严格别名"警告，尽管从技术上讲，这类结构违反的并非通常被称为"严格别名规则"的条款。

严格别名规则及相关规则的目的在于启用基于类型的别名分析。如果程序能够合法地创建这样一种情形：两个指向不相关类型的指针（例如 int * 和 float * ）可以同时存在，且两者都能用于对同一内存进行加载或存储操作（参见 SG12邮件组中的这封邮件 ），那么类型别名分析将遭到破坏。因此，任何看似能够创建此类情形的技术都必然引发未定义行为。

当需要将对象的字节解释为不同类型值时，可使用 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);               // 正确
n = std::bit_cast<std::int64_t>(d);          // 同样正确

在C语言中，聚合对象的复制和赋值是整体访问聚合对象的。但在C++中，这类操作总是通过成员函数调用执行，该函数访问的是各个子对象而非整个对象（对于联合体而言，则是复制对象表示，即通过 unsigned char 实现）。

关键词

reinterpret_cast

示例

#include <cassert>
#include <cstdint>
#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 " << std::showbase << 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);
    std::cout << (p2[0] == '\x7' ? "This system is little-endian\n"
                                 : "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

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

参考文献

参见