什么时候使用reinterpret_cast？

我对reinterpret_castvs 的适用性不感到困惑static_cast。根据我的阅读，一般规则是在编译时可以解释类型的情况下使用静态强制转换，因此使用单词static。这是C ++编译器内部也用于隐式强制转换的强制转换。

reinterpret_cast适用于两种情况：

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

我有点困惑的是我需要的一种用法，我从C调用C ++，C代码需要保留在C ++对象上，因此基本上它包含一个void*。应该使用哪种强制转换在void *和类型之间进行转换？

我已经看到了这两个的使用static_cast和reinterpret_cast？虽然从我一直阅读的内容来看static，由于转换可以在编译时进行，所以看起来更好。虽然它说用来reinterpret_cast从一种指针类型转换为另一种指针类型？

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应该是首选。

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; }

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

完整答案：

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

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

另一方面，在调用时reinterpret_cast，CPU不会调用任何计算。它只是像对待其他类型一样对待内存中的一组位。所以，当你转换int*到float*与此关键字，新的值（指针dereferecing之后）无关，在数学意义上的旧值。

示例：的确，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（big）或0000'0001'0000'0000（little endian）。重新解释广播后，p指针下的字节可以分别为0000'0000或0000'0001。如果您使用静态广播，则0000'0001无论使用哪种字节序，它始终为。

编辑：

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

reinterpret_castC ++标准未定义的含义。因此，理论上a reinterpret_cast可能会使您的程序崩溃。在实践中，编译器会尝试执行您期望的操作，这就是将要传递的内容解释为它们是要转换的类型。如果您知道将要使用的编译器可以做什么，则reinterpret_cast 可以使用它，但是要说它是可移植的就行了。

对于您描述的情况，几乎可以考虑reinterpret_cast使用的任何情况，都可以使用static_cast或其他替代方法。除其他事项外，标准还说了您对static_cast（§5.2.9）的期望：

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

因此，对于您的用例，标准化委员会打算供您使用似乎很清楚static_cast。

reinterpret_cast的一种用法是是否要对（IEEE 754）浮点数应用按位运算。一个例子是快速逆平方根技巧：

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

它将float的二进制表示形式视为整数，将其右移并从常数中减去它，从而使指数减半和取反。转换回浮点数后，将对其进行牛顿-拉夫森（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。

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

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

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

首先，您具有一些特定类型的数据，例如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

简介：这意味着将相同的内存用作不同的类型。因此，您可以将浮点数的二进制表示形式转换为浮点数，如上述的int类型。例如，0x80000000是-0（尾数和指数为null，但符号msb为1。这也适用于双打和长双打。

优化：我认为reinterpret_cast将在许多编译器中得到优化，而c广播是由指针算术进行的（该值必须复制到内存中，因为指针无法指向cpu寄存器）。

注意：在这两种情况下，都应在强制转换之前将强制转换值保存在变量中！此宏可以帮助：

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

使用的原因之一reinterpret_cast是基类没有vtable，而派生类却有。在这种情况下，static_cast和reinterpret_cast将导致不同的指针值（这将是由所提到的非典型情况下jalf以上）。就像免责声明一样，我并不是在说这是标准的一部分，而是几个广泛编译器的实现。

例如，使用以下代码：

#include <cstdio>

class A {
public:
    int i;
};

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

int main()
{
    B b;
    const A* a = static_cast<A*>(&b);
    const A* ar = reinterpret_cast<A*>(&b);

    printf("&b = %p\n", &b);
    printf(" a = %p\n", a);
    printf("ar = %p\n", ar);
    printf("difference = %ld\n", (long int)(a - ar));

    return 0;
}

输出如下：

＆b = 0x7ffe10e68b38
a = 0x7ffe10e68b40
ar = 0x7ffe10e68b38
差= 2

在我尝试过的所有编译器中（MSVC 2015＆2017，clang 8.0.0，gcc 9.2，icc 19.0.1- 有关最后3个信息，请参阅godbolt），结果static_cast与reinterpret_cast2 的结果之差（对于MSVC为4）。唯一警告差异的编译器是clang，具有：

17:16：警告：从类'B *'到非零偏移量'A *'的基址的'reinterpret_cast'行为与'static_cast'有所不同[-Wreinterpret-base-class]
const A * ar = reinterpret_cast（＆b） ;
^ ~~~~~~~~~~~~~~~~~~~~~~~
17:16：注意：在上载
const A * 时，请使用'static_cast'正确调整指针。ar = reinterpret_cast（＆b） ;
^ ~~~~~~~~~~~~~~~
static_cast

最后一个需要注意的是，如果基类没有任何数据成员（例如int i;）然后铛，GCC和ICC为返回相同的地址reinterpret_cast为static_cast，而MSVC还没有。

这是Avi Ginsburg程序的一种变体，它清楚地说明了reinterpret_castChris Luengo，flodin和cmdLP提到的属性：编译器将指向的内存位置视为是新类型的对象：

#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正确返回嵌入对象的地址，并且通过所创建的指针static_cast正确地给出数据字段的值。由生成的指针reinterpret_cast将其b存储位置视为一个普通的A对象，因此，当指针尝试获取数据字段时，它将返回一些特定于B的数据，就像该字段的内容一样。

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

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

快速解答：static_cast如果编译可使用，否则请求助reinterpret_cast。

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

在C ++中，void *无需任何强制转换就可以将指向对象的指针转换为该指针。但这反过来不是真的。您需要a static_cast来恢复原始指针。