何时使用reinterpret_cast？

Question

我对reinterpret_cast与static_cast的适用性有点困惑。 根据我所读到的内容，一般规则是当可以在编译时解释类型时使用静态强制转换，因此使用“静态”一词。 这也是 C++ 编译器在内部用于隐式转换的转换。

reinterpret_cast适用于两种场景：

• 将整数类型转换为指针类型，反之亦然，
• 将一种指针类型转换为另一种指针类型。 我的总体想法是这是不可移植的，应该避免。

我有点困惑的是我需要的一种用法，我从 C 调用 C++，而 C 代码需要保留 C++ 对象，所以基本上它保存一个 void*。 应该使用什么类型转换来在 void * 和 Class 类型之间进行转换？

我见过 static_cast 和 reinterpret_cast 的用法？ 尽管从我读到的内容来看，静态似乎更好，因为转换可以在编译时发生？ 虽然它说使用reinterpret_cast从一种指针类型转换为另一种指针类型？

Answer 1

C++ 标准保证以下几点：

static_cast指向和来自 void* 的指针会保留地址。 也就是说，下面的a、b和c都指向同一个地址：

int* a = new int();
void* b = static_cast<void*>(a);
int* c = static_cast<int*>(b);

reinterpret_cast仅保证如果将指针转换为不同的类型，然后reinterpret_cast将其返回到原始类型，您将获得原始值。 因此，在以下内容中：

int* a = new int();
void* b = reinterpret_cast<void*>(a);
int* c = reinterpret_cast<int*>(b);

a 和 c 包含相同的值，但 b 的值未指定。 （实际上，它通常包含与 a 和 c 相同的地址，但这在标准中没有指定，并且在具有更复杂内存系统的机器上可能不是这样.)

对于与 void* 之间的转换，应首选 static_cast。

Answer 2

需要reinterpret_cast的一种情况是与不透明数据类型交互时。 这种情况经常发生在程序员无法控制的供应商 API 中。 下面是一个人为的示例，其中供应商提供了一个用于存储和检索任意全局数据的 API：

// vendor.hpp
typedef struct _Opaque * VendorGlobalUserData;
void VendorSetUserData(VendorGlobalUserData p);
VendorGlobalUserData VendorGetUserData();

要使用此 API，程序员必须将其数据转换为 VendorGlobalUserData 并再次返回。 static_cast 不起作用，必须使用 reinterpret_cast：

// main.cpp
#include "vendor.hpp"
#include <iostream>
using namespace std;

struct MyUserData {
    MyUserData() : m(42) {}
    int m;
};

int main() {
    MyUserData u;

        // store global data
    VendorGlobalUserData d1;
//  d1 = &u;                                          // compile error
//  d1 = static_cast<VendorGlobalUserData>(&u);       // compile error
    d1 = reinterpret_cast<VendorGlobalUserData>(&u);  // ok
    VendorSetUserData(d1);

        // do other stuff...

        // retrieve global data
    VendorGlobalUserData d2 = VendorGetUserData();
    MyUserData * p = 0;
//  p = d2;                                           // compile error
//  p = static_cast<MyUserData *>(d2);                // compile error
    p = reinterpret_cast<MyUserData *>(d2);           // ok

    if (p) { cout << p->m << endl; }
    return 0;
}

下面是示例 API 的一种人为实现：

// vendor.cpp
static VendorGlobalUserData g = 0;
void VendorSetUserData(VendorGlobalUserData p) { g = p; }
VendorGlobalUserData VendorGetUserData() { return g; }

Answer 3

简短回答：
如果您不知道reinterpret_cast代表什么，请不要使用它。 如果您将来需要它，您就会知道。

完整答案：

让我们考虑基本的数字类型。

例如，当您将 int(12) 转换为 float (12.0f) 时，您的处理器需要调用一些计算，因为这两个数字具有不同的位表示形式。 这就是 static_cast 的含义。

另一方面，当您调用 reinterpret_cast 时，CPU 不会调用任何计算。 它只是将内存中的一组位视为另一种类型。 因此，当您使用此关键字将 int* 转换为 float* 时，新值（指针解引用后）与数学意义上的旧值无关（忽略这一事实）读取该值是未定义的行为）。

请注意，在reinterprt_cast'ing之后读取或修改值通常是未定义的行为。 大多数情况下，如果你想实现某些数据的位表示，你应该使用std::byte的指针或引用（从C++17开始），这几乎总是合法的操作。 其他“安全”类型有 char 和 unsigned char，但我想说它不应该在现代 C++ 中用于此目的，如 std::byte< /code> 具有更好的语义。

示例： 确实，reinterpret_cast 不可移植，原因有一个：字节顺序（字节序）。 但这往往是使用它的最佳理由。 让我们想象一下这个例子：你必须从文件中读取二进制 32 位数字，并且你知道它是大端字节序。 您的代码必须是通用的，并且必须能够在大端（例如某些 ARM）和小端（例如 x86）系统上正常工作。 所以你必须检查字节顺序。 它在编译时是众所周知的，因此您可以编写 constexpr 函数： 您可以编写一个函数来实现此目的：

/*constexpr*/ bool is_little_endian() {
  std::uint16_t x=0x0001;
  auto p = reinterpret_cast<std::uint8_t*>(&x);
  return *p != 0;
}

说明： x在内存中的二进制表示可以是0000'0000'0000'0001（大）或0000'0001'0000'0000代码>（小端）。 重新解释转换后，p 指针下的字节可能分别为 0000'0000 或 0000'0001。 如果您使用静态转换，则无论使用什么字节序，它都将始终为 0000'0001。

编辑：

_{在第一个版本中，我将示例函数 is_little_endian 设为 constexpr。 它在最新的 gcc (8.3.0) 上编译得很好，但标准说它是非法的。 clang 编译器拒绝编译它（这是正确的）。}

Answer 4

C++ 标准未定义reinterpret_cast 的含义。 因此，理论上，reinterpret_cast 可能会使您的程序崩溃。 实际上，编译器会尝试执行您期望的操作，即解释您传入的内容，就好像它们是您要转换的类型一样。 如果您知道要使用的编译器对reinterpret_cast做什么，您就可以使用它，但说它是可移植的是在撒谎。

对于您描述的情况，以及几乎任何您可能考虑 reinterpret_cast 的情况，您都可以使用 static_cast 或其他替代方案。 除其他事项外，该标准还规定了您对 static_cast 的期望（第 5.2.9 节）：

“指向 cv void 的指针”类型的右值可以显式转换为指向对象类型的指针。 指向对象的指针类型的值转换为“指向 cv void 的指针”并返回到原始指针类型将具有其原始值。

因此，对于您的用例，标准化委员会似乎很清楚地希望您使用static_cast。

Answer 5

reinterpret_cast 的一种用途是如果您想对 (IEEE 754) 浮点数应用按位运算。 其中一个例子是快速逆平方根技巧：

https://en.wikipedia.org/ wiki/Fast_inverse_square_root#Overview_of_the_code

它将浮点数的二进制表示形式视为整数，将其右移并从常数中减去它，从而将指数减半并求负。 转换回浮点数后，它会进行 Newton-Raphson 迭代，以使该近似值更加精确：

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the deuce? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

这最初是用 C 编写的，因此使用 C 强制转换，但类似的 C++ 强制转换是 reinterpret_cast。

Answer 6

这是 Avi Ginsburg 程序的一个变体，它清楚地说明了 Chris Luengo、flodin 和 cmdLP 提到的 reinterpret_cast 的属性：编译器将指向的内存位置视为对象new type:

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class A
{
public:
    int i;
};

class B : public A
{
public:
    virtual void f() {}
};

int main()
{
    string s;
    B b;
    b.i = 0;
    A* as = static_cast<A*>(&b);
    A* ar = reinterpret_cast<A*>(&b);
    B* c = reinterpret_cast<B*>(ar);
    
    cout << "as->i = " << hex << setfill('0')  << as->i << "\n";
    cout << "ar->i = " << ar->i << "\n";
    cout << "b.i   = " << b.i << "\n";
    cout << "c->i  = " << c->i << "\n";
    cout << "\n";
    cout << "&(as->i) = " << &(as->i) << "\n";
    cout << "&(ar->i) = " << &(ar->i) << "\n";
    cout << "&(b.i) = " << &(b.i) << "\n";
    cout << "&(c->i) = " << &(c->i) << "\n";
    cout << "\n";
    cout << "&b = " << &b << "\n";
    cout << "as = " << as << "\n";
    cout << "ar = " << ar << "\n";
    cout << "c  = " << c  << "\n";
    
    cout << "Press ENTER to exit.\n";
    getline(cin,s);
}

输出如下：

as->i = 0
ar->i = 50ee64
b.i   = 0
c->i  = 0

&(as->i) = 00EFF978
&(ar->i) = 00EFF974
&(b.i)   = 00EFF978
&(c->i)  = 00EFF978

&b = 00EFF974
as = 00EFF978
ar = 00EFF974
c  = 00EFF974
Press ENTER to exit.

可以看出，B 对象首先作为 B 特定数据构建在内存中，然后是嵌入的 A 对象。 static_cast 正确返回嵌入的 A 对象的地址，并且 static_cast 创建的指针正确给出数据字段的值。 由 reinterpret_cast 生成的指针将 b 的内存位置视为普通 A 对象，因此当指针尝试获取数据字段时，它会返回一些 B-特定数据就好像它是该字段的内容一样。

reinterpret_cast 的一种用途是将指针转换为无符号整数（当指针和无符号整数大小相同时）：

int i;
unsigned int u = reinterpret_cast(&i);

Answer 7

您可以使用reinterprete_cast 在编译时检查继承。
看这里：
使用reinterpret_cast在编译时检查继承

Answer 8

首先，您有一些特定类型的数据，例如 int：

int x = 0x7fffffff://==nan in binary representation

然后您想要访问与其他类型（例如 float）相同的变量：
您可以在

float y = reinterpret_cast<float&>(x);

//this could only be used in cpp, looks like a function with template-parameters

或

float y = *(float*)&(x);

//this could be used in c and cpp

Brief 之间做出决定：这意味着相同的内存被用作不同的类型。 因此，您可以将浮点数的二进制表示形式（如上面的 int 类型）转换为浮点数。 例如，0x80000000 是 -0（尾数和指数为空，但符号 MSB 为 1。这也适用于双精度数和长双精度数。

优化：我认为在许多编译器中，reinterpret_cast 会得到优化，而 c 转换是由pointerarithmetic创建（该值必须复制到内存，因为指针无法指向cpu寄存器）

注意：在这两种情况下，您都应该在转换之前将转换后的值保存在变量中！

#define asvar(x) ({decltype(x) __tmp__ = (x); __tmp__; })

Answer 9

template <class outType, class inType>
outType safe_cast(inType pointer)
{
    void* temp = static_cast<void*>(pointer);
    return static_cast<outType>(temp);
}

我尝试总结并使用模板编写了一个简单的安全转换。
请注意，此解决方案不保证在函数上强制转换指针。

Answer 10

快速回答：如果可以编译，请使用static_cast，否则诉诸reinterpret_cast。

Answer 11

阅读常见问题解答！ 在 C 中保存 C++ 数据可能存在风险。

在 C++ 中，指向对象的指针无需任何强制转换即可转换为 void *。 但反之则不然。 您需要一个 static_cast 来获取原始指针。