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

#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创建的指针正确地给出data字段的值。由reinterpret_cast生成的指针将b的内存位置视为普通的a对象，因此当指针试图获取数据字段时，它将返回一些特定于b的数据，就像它是该字段的内容一样。

reinterpret_cast的一个用途是将指针转换为无符号整数(当指针和无符号整数大小相同时):

int我; Unsigned int u = reinterpret_cast< Unsigned int>(&i);

c++标准保证了以下内容:

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

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

Reinterpret_cast只保证如果将一个指针强制转换为不同的类型，然后将其重新转换为原始类型，则得到原始值。下面是:

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

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

对于void*和void*之间的强制转换，应该优先使用static_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);
}

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

快速回答:如果编译static_cast，则使用static_cast，否则使用reinterpret_cast。

reinterpret_cast的含义不是由c++标准定义的。因此，理论上reinterpret_cast可能导致程序崩溃。在实践中，编译器试图做你所期望的事情，也就是解释你传入的二进制位，就好像它们是你要强制转换的类型一样。如果你知道你将要使用的编译器对reinterpret_cast做了什么，你就可以使用它，但是说它是可移植的是在撒谎。

对于您所描述的情况，以及您可能会考虑reinterpret_cast的大多数情况，您可以使用static_cast或其他替代方法。在其他事情中，标准有这样说你可以期待static_cast(§5.2.9):

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

因此，对于您的用例，标准化委员会显然希望您使用static_cast。